@haaaiawd/second-nature 0.1.17 → 0.1.18

package/runtime/connectors/base/execution-policy.d.ts

@@ -1,47 +1,47 @@
-import type { CapabilityIntent, ConnectorRequest, ExecutionPlan } from "./contract.js";
-export type EffectSemanticsClass = "read_only" | "side_effect" | "task_claim" | "keepalive";
-export declare function classifyConnectorIntentEffect(intent: CapabilityIntent): EffectSemanticsClass;
-export interface EffectCommitLedgerPort {
-    getOrCreateIntentCommitRecord(input: {
-        decisionId: string;
-        intentId: string;
-        idempotencyKey: string;
-        effectClass: string;
-    }): Promise<{
-        existing: boolean;
-        record: {
-            id: string;
-            state: string;
-            outcomeRef?: string;
-        };
-    }>;
-}
-/** In-memory ledger for tests and offline harnesses. */
-export declare class InMemoryEffectCommitLedger implements EffectCommitLedgerPort {
-    private readonly byKey;
-    private key;
-    getOrCreateIntentCommitRecord(input: {
-        decisionId: string;
-        intentId: string;
-        idempotencyKey: string;
-        effectClass: string;
-    }): Promise<{
-        existing: boolean;
-        record: {
-            id: string;
-            state: string;
-            outcomeRef?: string;
-        };
-    }>;
-    /** Test seam: mark a key as already committed with replayable outcome. */
-    seedCommitted(decisionId: string, idempotencyKey: string, outcomeRef: string): void;
-    markState(decisionId: string, idempotencyKey: string, state: string): void;
-}
-export interface EnforceExecutionPolicyDeps {
-    effectCommitLedger?: EffectCommitLedgerPort;
-}
-export declare function enforceExecutionPolicy(plan: ExecutionPlan, intent: CapabilityIntent, request: ConnectorRequest, deps: EnforceExecutionPolicyDeps): Promise<{
-    skipAdapter: boolean;
-    existingOutcomeRef?: string;
-    effectCommitId?: string;
-}>;
+import type { CapabilityIntent, ConnectorRequest, ExecutionPlan } from "./contract.js";
+export type EffectSemanticsClass = "read_only" | "side_effect" | "task_claim" | "keepalive";
+export declare function classifyConnectorIntentEffect(intent: CapabilityIntent): EffectSemanticsClass;
+export interface EffectCommitLedgerPort {
+    getOrCreateIntentCommitRecord(input: {
+        decisionId: string;
+        intentId: string;
+        idempotencyKey: string;
+        effectClass: string;
+    }): Promise<{
+        existing: boolean;
+        record: {
+            id: string;
+            state: string;
+            outcomeRef?: string;
+        };
+    }>;
+}
+/** In-memory ledger for tests and offline harnesses. */
+export declare class InMemoryEffectCommitLedger implements EffectCommitLedgerPort {
+    private readonly byKey;
+    private key;
+    getOrCreateIntentCommitRecord(input: {
+        decisionId: string;
+        intentId: string;
+        idempotencyKey: string;
+        effectClass: string;
+    }): Promise<{
+        existing: boolean;
+        record: {
+            id: string;
+            state: string;
+            outcomeRef?: string;
+        };
+    }>;
+    /** Test seam: mark a key as already committed with replayable outcome. */
+    seedCommitted(decisionId: string, idempotencyKey: string, outcomeRef: string): void;
+    markState(decisionId: string, idempotencyKey: string, state: string): void;
+}
+export interface EnforceExecutionPolicyDeps {
+    effectCommitLedger?: EffectCommitLedgerPort;
+}
+export declare function enforceExecutionPolicy(plan: ExecutionPlan, intent: CapabilityIntent, request: ConnectorRequest, deps: EnforceExecutionPolicyDeps): Promise<{
+    skipAdapter: boolean;
+    existingOutcomeRef?: string;
+    effectCommitId?: string;
+}>;

package/runtime/connectors/base/execution-policy.js

@@ -1,82 +1,82 @@
-/**
- * Side-effect idempotency + degraded-channel gate + effect commit replay (T3.2.1).
- * Aligns with connector-system.detail §3.6 enforceExecutionPolicy.
- */
-import * as crypto from "node:crypto";
-import { ConnectorPolicyError } from "./failure-taxonomy.js";
-const READONLY = new Set([
-    "feed.read",
-    "notification.list",
-    "work.discover",
-]);
-export function classifyConnectorIntentEffect(intent) {
-    if (intent === "agent.heartbeat")
-        return "keepalive";
-    if (intent === "task.claim")
-        return "task_claim";
-    if (READONLY.has(intent))
-        return "read_only";
-    return "side_effect";
-}
-/** In-memory ledger for tests and offline harnesses. */
-export class InMemoryEffectCommitLedger {
-    byKey = new Map();
-    key(decisionId, idempotencyKey) {
-        return `${decisionId}::${idempotencyKey}`;
-    }
-    async getOrCreateIntentCommitRecord(input) {
-        const k = this.key(input.decisionId, input.idempotencyKey);
-        const hit = this.byKey.get(k);
-        if (hit) {
-            return { existing: true, record: hit };
-        }
-        const id = crypto.randomUUID();
-        const rec = { id, state: "planned", outcomeRef: undefined };
-        this.byKey.set(k, rec);
-        return { existing: false, record: rec };
-    }
-    /** Test seam: mark a key as already committed with replayable outcome. */
-    seedCommitted(decisionId, idempotencyKey, outcomeRef) {
-        const id = crypto.randomUUID();
-        this.byKey.set(this.key(decisionId, idempotencyKey), { id, state: "committed", outcomeRef });
-    }
-    markState(decisionId, idempotencyKey, state) {
-        const k = this.key(decisionId, idempotencyKey);
-        const cur = this.byKey.get(k);
-        if (!cur)
-            throw new Error("ledger_seed_missing");
-        this.byKey.set(k, { ...cur, state });
-    }
-}
-export async function enforceExecutionPolicy(plan, intent, request, deps) {
-    const semantics = classifyConnectorIntentEffect(intent);
-    if ((semantics === "side_effect" || semantics === "task_claim") && !plan.idempotencyKey?.trim()) {
-        throw new ConnectorPolicyError("permanent_input_error", "side_effect_requires_idempotency_key");
-    }
-    if (plan.degraded && (semantics === "side_effect" || semantics === "task_claim")) {
-        throw new ConnectorPolicyError("semantic_rejection", "degraded_channel_not_allowed_for_side_effect");
-    }
-    if (plan.idempotencyKey && deps.effectCommitLedger) {
-        if (!request.decisionId?.trim() || !request.intentId?.trim()) {
-            throw new ConnectorPolicyError("permanent_input_error", "effect_commit_requires_decision_and_intent_id");
-        }
-        const lookup = await deps.effectCommitLedger.getOrCreateIntentCommitRecord({
-            decisionId: request.decisionId,
-            intentId: request.intentId,
-            idempotencyKey: plan.idempotencyKey,
-            effectClass: semantics,
-        });
-        if (lookup.existing && lookup.record.state === "committed") {
-            return {
-                skipAdapter: true,
-                existingOutcomeRef: lookup.record.outcomeRef,
-                effectCommitId: lookup.record.id,
-            };
-        }
-        if (lookup.existing && (lookup.record.state === "dispatched" || lookup.record.state === "reconcile")) {
-            throw new ConnectorPolicyError("concurrency_conflict", "effect_commit_requires_reconcile");
-        }
-        return { skipAdapter: false, effectCommitId: lookup.record.id };
-    }
-    return { skipAdapter: false };
-}
+/**
+ * Side-effect idempotency + degraded-channel gate + effect commit replay (T3.2.1).
+ * Aligns with connector-system.detail §3.6 enforceExecutionPolicy.
+ */
+import * as crypto from "node:crypto";
+import { ConnectorPolicyError } from "./failure-taxonomy.js";
+const READONLY = new Set([
+    "feed.read",
+    "notification.list",
+    "work.discover",
+]);
+export function classifyConnectorIntentEffect(intent) {
+    if (intent === "agent.heartbeat")
+        return "keepalive";
+    if (intent === "task.claim")
+        return "task_claim";
+    if (READONLY.has(intent))
+        return "read_only";
+    return "side_effect";
+}
+/** In-memory ledger for tests and offline harnesses. */
+export class InMemoryEffectCommitLedger {
+    byKey = new Map();
+    key(decisionId, idempotencyKey) {
+        return `${decisionId}::${idempotencyKey}`;
+    }
+    async getOrCreateIntentCommitRecord(input) {
+        const k = this.key(input.decisionId, input.idempotencyKey);
+        const hit = this.byKey.get(k);
+        if (hit) {
+            return { existing: true, record: hit };
+        }
+        const id = crypto.randomUUID();
+        const rec = { id, state: "planned", outcomeRef: undefined };
+        this.byKey.set(k, rec);
+        return { existing: false, record: rec };
+    }
+    /** Test seam: mark a key as already committed with replayable outcome. */
+    seedCommitted(decisionId, idempotencyKey, outcomeRef) {
+        const id = crypto.randomUUID();
+        this.byKey.set(this.key(decisionId, idempotencyKey), { id, state: "committed", outcomeRef });
+    }
+    markState(decisionId, idempotencyKey, state) {
+        const k = this.key(decisionId, idempotencyKey);
+        const cur = this.byKey.get(k);
+        if (!cur)
+            throw new Error("ledger_seed_missing");
+        this.byKey.set(k, { ...cur, state });
+    }
+}
+export async function enforceExecutionPolicy(plan, intent, request, deps) {
+    const semantics = classifyConnectorIntentEffect(intent);
+    if ((semantics === "side_effect" || semantics === "task_claim") && !plan.idempotencyKey?.trim()) {
+        throw new ConnectorPolicyError("permanent_input_error", "side_effect_requires_idempotency_key");
+    }
+    if (plan.degraded && (semantics === "side_effect" || semantics === "task_claim")) {
+        throw new ConnectorPolicyError("semantic_rejection", "degraded_channel_not_allowed_for_side_effect");
+    }
+    if (plan.idempotencyKey && deps.effectCommitLedger) {
+        if (!request.decisionId?.trim() || !request.intentId?.trim()) {
+            throw new ConnectorPolicyError("permanent_input_error", "effect_commit_requires_decision_and_intent_id");
+        }
+        const lookup = await deps.effectCommitLedger.getOrCreateIntentCommitRecord({
+            decisionId: request.decisionId,
+            intentId: request.intentId,
+            idempotencyKey: plan.idempotencyKey,
+            effectClass: semantics,
+        });
+        if (lookup.existing && lookup.record.state === "committed") {
+            return {
+                skipAdapter: true,
+                existingOutcomeRef: lookup.record.outcomeRef,
+                effectCommitId: lookup.record.id,
+            };
+        }
+        if (lookup.existing && (lookup.record.state === "dispatched" || lookup.record.state === "reconcile")) {
+            throw new ConnectorPolicyError("concurrency_conflict", "effect_commit_requires_reconcile");
+        }
+        return { skipAdapter: false, effectCommitId: lookup.record.id };
+    }
+    return { skipAdapter: false };
+}

package/runtime/connectors/base/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./contract.js";
-export * from "./manifest.js";
-export * from "./map-life-evidence.js";
-export * from "./failure-taxonomy.js";
-export * from "./route-planner.js";
-export * from "./channel-health.js";
-export * from "./policy-layer.js";
-export * from "./execution-policy.js";
+export * from "./contract.js";
+export * from "./manifest.js";
+export * from "./map-life-evidence.js";
+export * from "./failure-taxonomy.js";
+export * from "./route-planner.js";
+export * from "./channel-health.js";
+export * from "./policy-layer.js";
+export * from "./execution-policy.js";

package/runtime/connectors/base/index.js

@@ -1,8 +1,8 @@
-export * from "./contract.js";
-export * from "./manifest.js";
-export * from "./map-life-evidence.js";
-export * from "./failure-taxonomy.js";
-export * from "./route-planner.js";
-export * from "./channel-health.js";
-export * from "./policy-layer.js";
-export * from "./execution-policy.js";
+export * from "./contract.js";
+export * from "./manifest.js";
+export * from "./map-life-evidence.js";
+export * from "./failure-taxonomy.js";
+export * from "./route-planner.js";
+export * from "./channel-health.js";
+export * from "./policy-layer.js";
+export * from "./execution-policy.js";

package/runtime/connectors/base/manifest.d.ts

@@ -1,64 +1,64 @@
-import { z } from "zod";
-import { type CapabilityIntent, type ChannelType } from "./contract.js";
-declare const connectorManifestSchema: z.ZodObject<{
-    platformId: z.ZodString;
-    supportedCapabilities: z.ZodArray<z.ZodEnum<{
-        "feed.read": "feed.read";
-        "post.publish": "post.publish";
-        "comment.reply": "comment.reply";
-        "notification.list": "notification.list";
-        "message.send": "message.send";
-        "agent.register": "agent.register";
-        "agent.heartbeat": "agent.heartbeat";
-        "work.discover": "work.discover";
-        "task.claim": "task.claim";
-    }>>;
-    channelPriority: z.ZodArray<z.ZodEnum<{
-        api_rest: "api_rest";
-        api_rpc: "api_rpc";
-        a2a: "a2a";
-        mcp: "mcp";
-        cli: "cli";
-        skill: "skill";
-        browser: "browser";
-    }>>;
-    credentialTypes: z.ZodArray<z.ZodString>;
-    degradedChannels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        api_rest: "api_rest";
-        api_rpc: "api_rpc";
-        a2a: "a2a";
-        mcp: "mcp";
-        cli: "cli";
-        skill: "skill";
-        browser: "browser";
-    }>>>;
-    sourceRefPolicy: z.ZodOptional<z.ZodObject<{
-        minSourceRefs: z.ZodDefault<z.ZodNumber>;
-        rejectInlineSensitivePayload: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ConnectorManifest = z.infer<typeof connectorManifestSchema>;
-export declare class CapabilityContractRegistry {
-    private readonly byPlatform;
-    register(manifest: ConnectorManifest): void;
-    loadManifest(platformId: string): ConnectorManifest;
-    listRegisteredPlatformIds(): string[];
-    hasCapability(platformId: string, intent: CapabilityIntent): boolean;
-    listCapabilities(platformId: string): CapabilityIntent[];
-    listChannels(platformId: string): ChannelType[];
-}
-/** T3.1.1 contract name for manifest-first registry. */
-export declare const ConnectorManifestRegistry: typeof CapabilityContractRegistry;
-export type ConnectorManifestRegistry = CapabilityContractRegistry;
-export declare function describeConnector(registry: CapabilityContractRegistry, platformId: string): ConnectorManifest;
-export declare function checkConnector(registry: CapabilityContractRegistry, platformId: string): {
-    ok: boolean;
-    errors: string[];
-};
-export declare function discoverCapabilities(registry: CapabilityContractRegistry): Array<{
-    platformId: string;
-    capabilities: CapabilityIntent[];
-    degradedChannels?: ChannelType[];
-}>;
-export declare function parseConnectorManifest(input: unknown): ConnectorManifest;
-export {};
+import { z } from "zod";
+import { type CapabilityIntent, type ChannelType } from "./contract.js";
+declare const connectorManifestSchema: z.ZodObject<{
+    platformId: z.ZodString;
+    supportedCapabilities: z.ZodArray<z.ZodEnum<{
+        "feed.read": "feed.read";
+        "post.publish": "post.publish";
+        "comment.reply": "comment.reply";
+        "notification.list": "notification.list";
+        "message.send": "message.send";
+        "agent.register": "agent.register";
+        "agent.heartbeat": "agent.heartbeat";
+        "work.discover": "work.discover";
+        "task.claim": "task.claim";
+    }>>;
+    channelPriority: z.ZodArray<z.ZodEnum<{
+        api_rest: "api_rest";
+        api_rpc: "api_rpc";
+        a2a: "a2a";
+        mcp: "mcp";
+        cli: "cli";
+        skill: "skill";
+        browser: "browser";
+    }>>;
+    credentialTypes: z.ZodArray<z.ZodString>;
+    degradedChannels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        api_rest: "api_rest";
+        api_rpc: "api_rpc";
+        a2a: "a2a";
+        mcp: "mcp";
+        cli: "cli";
+        skill: "skill";
+        browser: "browser";
+    }>>>;
+    sourceRefPolicy: z.ZodOptional<z.ZodObject<{
+        minSourceRefs: z.ZodDefault<z.ZodNumber>;
+        rejectInlineSensitivePayload: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConnectorManifest = z.infer<typeof connectorManifestSchema>;
+export declare class CapabilityContractRegistry {
+    private readonly byPlatform;
+    register(manifest: ConnectorManifest): void;
+    loadManifest(platformId: string): ConnectorManifest;
+    listRegisteredPlatformIds(): string[];
+    hasCapability(platformId: string, intent: CapabilityIntent): boolean;
+    listCapabilities(platformId: string): CapabilityIntent[];
+    listChannels(platformId: string): ChannelType[];
+}
+/** T3.1.1 contract name for manifest-first registry. */
+export declare const ConnectorManifestRegistry: typeof CapabilityContractRegistry;
+export type ConnectorManifestRegistry = CapabilityContractRegistry;
+export declare function describeConnector(registry: CapabilityContractRegistry, platformId: string): ConnectorManifest;
+export declare function checkConnector(registry: CapabilityContractRegistry, platformId: string): {
+    ok: boolean;
+    errors: string[];
+};
+export declare function discoverCapabilities(registry: CapabilityContractRegistry): Array<{
+    platformId: string;
+    capabilities: CapabilityIntent[];
+    degradedChannels?: ChannelType[];
+}>;
+export declare function parseConnectorManifest(input: unknown): ConnectorManifest;
+export {};

package/runtime/connectors/base/manifest.js

@@ -1,86 +1,86 @@
-import { z } from "zod";
-import { CAPABILITY_INTENTS, CHANNEL_TYPES } from "./contract.js";
-const sourceRefPolicySchema = z
-    .object({
-    minSourceRefs: z.number().int().min(0).default(1),
-    rejectInlineSensitivePayload: z.boolean().optional(),
-})
-    .optional();
-const connectorManifestSchema = z.object({
-    platformId: z.string().min(1),
-    supportedCapabilities: z.array(z.enum(CAPABILITY_INTENTS)).min(1),
-    channelPriority: z.array(z.enum(CHANNEL_TYPES)).min(1),
-    credentialTypes: z.array(z.string().min(1)).min(1),
-    degradedChannels: z.array(z.enum(CHANNEL_TYPES)).optional(),
-    sourceRefPolicy: sourceRefPolicySchema,
-});
-export class CapabilityContractRegistry {
-    byPlatform = new Map();
-    register(manifest) {
-        const parsed = connectorManifestSchema.parse(manifest);
-        this.byPlatform.set(parsed.platformId, parsed);
-    }
-    loadManifest(platformId) {
-        const found = this.byPlatform.get(platformId);
-        if (!found) {
-            throw new Error(`connector_manifest_not_found:${platformId}`);
-        }
-        return found;
-    }
-    listRegisteredPlatformIds() {
-        return [...this.byPlatform.keys()];
-    }
-    hasCapability(platformId, intent) {
-        const manifest = this.loadManifest(platformId);
-        return manifest.supportedCapabilities.includes(intent);
-    }
-    listCapabilities(platformId) {
-        return [...this.loadManifest(platformId).supportedCapabilities];
-    }
-    listChannels(platformId) {
-        return [...this.loadManifest(platformId).channelPriority];
-    }
-}
-/** T3.1.1 contract name for manifest-first registry. */
-export const ConnectorManifestRegistry = CapabilityContractRegistry;
-export function describeConnector(registry, platformId) {
-    return registry.loadManifest(platformId);
-}
-export function checkConnector(registry, platformId) {
-    const errors = [];
-    try {
-        const manifest = registry.loadManifest(platformId);
-        if (manifest.supportedCapabilities.length === 0) {
-            errors.push("capability_list_empty");
-        }
-        if (manifest.channelPriority.length === 0) {
-            errors.push("channel_priority_empty");
-        }
-        if (manifest.credentialTypes.length === 0) {
-            errors.push("credential_types_empty");
-        }
-        const degraded = manifest.degradedChannels ?? [];
-        for (const channel of degraded) {
-            if (!manifest.channelPriority.includes(channel)) {
-                errors.push(`degraded_channel_not_in_priority:${channel}`);
-            }
-        }
-    }
-    catch (error) {
-        errors.push(error instanceof Error ? error.message : String(error));
-    }
-    return { ok: errors.length === 0, errors };
-}
-export function discoverCapabilities(registry) {
-    return registry.listRegisteredPlatformIds().map((platformId) => {
-        const manifest = registry.loadManifest(platformId);
-        return {
-            platformId,
-            capabilities: [...manifest.supportedCapabilities],
-            degradedChannels: manifest.degradedChannels,
-        };
-    });
-}
-export function parseConnectorManifest(input) {
-    return connectorManifestSchema.parse(input);
-}
+import { z } from "zod";
+import { CAPABILITY_INTENTS, CHANNEL_TYPES } from "./contract.js";
+const sourceRefPolicySchema = z
+    .object({
+    minSourceRefs: z.number().int().min(0).default(1),
+    rejectInlineSensitivePayload: z.boolean().optional(),
+})
+    .optional();
+const connectorManifestSchema = z.object({
+    platformId: z.string().min(1),
+    supportedCapabilities: z.array(z.enum(CAPABILITY_INTENTS)).min(1),
+    channelPriority: z.array(z.enum(CHANNEL_TYPES)).min(1),
+    credentialTypes: z.array(z.string().min(1)).min(1),
+    degradedChannels: z.array(z.enum(CHANNEL_TYPES)).optional(),
+    sourceRefPolicy: sourceRefPolicySchema,
+});
+export class CapabilityContractRegistry {
+    byPlatform = new Map();
+    register(manifest) {
+        const parsed = connectorManifestSchema.parse(manifest);
+        this.byPlatform.set(parsed.platformId, parsed);
+    }
+    loadManifest(platformId) {
+        const found = this.byPlatform.get(platformId);
+        if (!found) {
+            throw new Error(`connector_manifest_not_found:${platformId}`);
+        }
+        return found;
+    }
+    listRegisteredPlatformIds() {
+        return [...this.byPlatform.keys()];
+    }
+    hasCapability(platformId, intent) {
+        const manifest = this.loadManifest(platformId);
+        return manifest.supportedCapabilities.includes(intent);
+    }
+    listCapabilities(platformId) {
+        return [...this.loadManifest(platformId).supportedCapabilities];
+    }
+    listChannels(platformId) {
+        return [...this.loadManifest(platformId).channelPriority];
+    }
+}
+/** T3.1.1 contract name for manifest-first registry. */
+export const ConnectorManifestRegistry = CapabilityContractRegistry;
+export function describeConnector(registry, platformId) {
+    return registry.loadManifest(platformId);
+}
+export function checkConnector(registry, platformId) {
+    const errors = [];
+    try {
+        const manifest = registry.loadManifest(platformId);
+        if (manifest.supportedCapabilities.length === 0) {
+            errors.push("capability_list_empty");
+        }
+        if (manifest.channelPriority.length === 0) {
+            errors.push("channel_priority_empty");
+        }
+        if (manifest.credentialTypes.length === 0) {
+            errors.push("credential_types_empty");
+        }
+        const degraded = manifest.degradedChannels ?? [];
+        for (const channel of degraded) {
+            if (!manifest.channelPriority.includes(channel)) {
+                errors.push(`degraded_channel_not_in_priority:${channel}`);
+            }
+        }
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return { ok: errors.length === 0, errors };
+}
+export function discoverCapabilities(registry) {
+    return registry.listRegisteredPlatformIds().map((platformId) => {
+        const manifest = registry.loadManifest(platformId);
+        return {
+            platformId,
+            capabilities: [...manifest.supportedCapabilities],
+            degradedChannels: manifest.degradedChannels,
+        };
+    });
+}
+export function parseConnectorManifest(input) {
+    return connectorManifestSchema.parse(input);
+}

package/runtime/connectors/base/map-life-evidence.d.ts

@@ -1,16 +1,16 @@
-/**
- * Maps normalized connector success results to `LifeEvidenceCandidate` (T3.1.2).
- * Returns null when evidence cannot be source-backed (no refs, wrong intent, or failure).
- */
-import type { CapabilityIntent, ConnectorResult } from "./contract.js";
-import type { LifeEvidenceCandidate, Sensitivity } from "../../storage/life-evidence/types.js";
-/**
- * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
- */
-export declare function mapLifeEvidence(input: {
-    platformId: string;
-    intent: CapabilityIntent;
-    result: ConnectorResult<unknown>;
-    observedAt?: string;
-    sensitivityOverride?: Sensitivity;
-}): LifeEvidenceCandidate | null;
+/**
+ * Maps normalized connector success results to `LifeEvidenceCandidate` (T3.1.2).
+ * Returns null when evidence cannot be source-backed (no refs, wrong intent, or failure).
+ */
+import type { CapabilityIntent, ConnectorResult } from "./contract.js";
+import type { LifeEvidenceCandidate, Sensitivity } from "../../storage/life-evidence/types.js";
+/**
+ * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
+ */
+export declare function mapLifeEvidence(input: {
+    platformId: string;
+    intent: CapabilityIntent;
+    result: ConnectorResult<unknown>;
+    observedAt?: string;
+    sensitivityOverride?: Sensitivity;
+}): LifeEvidenceCandidate | null;