@haaaiawd/second-nature 0.1.27 → 0.1.29

package/runtime/cli/read-models/index.js

@@ -55,19 +55,31 @@ function buildCredentialNextStep(status) {
         return "verify_or_re_create_credential_then_re_import";
     return undefined;
 }
-/**
- * T1.2.4: count persisted Quiet artifact JSON files under `.second-nature/quiet/{day}/`
- * so `loadQuiet` / `loadDailyReport` can reflect Quiet artifacts in the read model.
- */
-function countQuietArtifactsForDay(workspaceRoot, day) {
+function classifyQuietArtifactsForDay(workspaceRoot, day) {
     try {
         const dir = path.join(workspaceRoot, ".second-nature", "quiet", day);
         if (!fs.existsSync(dir))
-            return 0;
-        return fs.readdirSync(dir).filter((f) => f.endsWith(".json")).length;
+            return { reportArtifacts: 0, emptyStateArtifacts: 0, totalArtifacts: 0 };
+        let reportArtifacts = 0;
+        let emptyStateArtifacts = 0;
+        let totalArtifacts = 0;
+        for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".json"))) {
+            totalArtifacts++;
+            try {
+                const raw = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+                if (raw.write?.kind === "empty_state")
+                    emptyStateArtifacts++;
+                else
+                    reportArtifacts++;
+            }
+            catch {
+                reportArtifacts++;
+            }
+        }
+        return { reportArtifacts, emptyStateArtifacts, totalArtifacts };
     }
     catch {
-        return 0;
+        return { reportArtifacts: 0, emptyStateArtifacts: 0, totalArtifacts: 0 };
     }
 }
 /**
@@ -78,22 +90,26 @@ function countRecentQuietArtifacts(workspaceRoot, windowDays = 2) {
     try {
         const quietRoot = path.join(workspaceRoot, ".second-nature", "quiet");
         if (!fs.existsSync(quietRoot))
-            return { totalArtifacts: 0, recentDays: [] };
+            return { totalArtifacts: 0, reportArtifacts: 0, emptyStateArtifacts: 0, recentDays: [] };
         const now = Date.now();
         const recentDays = [];
         let total = 0;
+        let reports = 0;
+        let emptyStates = 0;
         for (let i = 0; i < windowDays; i++) {
             const d = new Date(now - i * 86400000).toISOString().slice(0, 10);
-            const count = countQuietArtifactsForDay(workspaceRoot, d);
-            if (count > 0) {
+            const count = classifyQuietArtifactsForDay(workspaceRoot, d);
+            if (count.totalArtifacts > 0) {
                 recentDays.push(d);
-                total += count;
+                total += count.totalArtifacts;
+                reports += count.reportArtifacts;
+                emptyStates += count.emptyStateArtifacts;
             }
         }
-        return { totalArtifacts: total, recentDays };
+        return { totalArtifacts: total, reportArtifacts: reports, emptyStateArtifacts: emptyStates, recentDays };
     }
     catch {
-        return { totalArtifacts: 0, recentDays: [] };
+        return { totalArtifacts: 0, reportArtifacts: 0, emptyStateArtifacts: 0, recentDays: [] };
     }
 }
 function mapRuntimeStatus(attempt) {
@@ -282,7 +298,7 @@ export function createCliReadModels(deps) {
             // into the daily report sourceRefs so the read model reflects artifacts written by
             // `persistQuietArtifactToWorkspace` (closes the canonical read/write gap for loadDailyReport).
             const fsArtifactCount = deps.workspaceRoot
-                ? countQuietArtifactsForDay(deps.workspaceRoot, day)
+                ? classifyQuietArtifactsForDay(deps.workspaceRoot, day).reportArtifacts
                 : 0;
             const report = bundle.dailyReports[0];
             const existingSources = report?.sources ?? [];
@@ -314,15 +330,16 @@ export function createCliReadModels(deps) {
             // journal path is empty.
             const quietArtifacts = deps.workspaceRoot
                 ? countRecentQuietArtifacts(deps.workspaceRoot, 2)
-                : { totalArtifacts: 0, recentDays: [] };
-            const totalSourceCount = bundle.sourceCount + quietArtifacts.totalArtifacts;
-            const totalReportCount = bundle.dailyReports.length + quietArtifacts.totalArtifacts;
+                : { totalArtifacts: 0, reportArtifacts: 0, emptyStateArtifacts: 0, recentDays: [] };
+            const totalSourceCount = bundle.sourceCount + quietArtifacts.reportArtifacts;
+            const totalReportCount = bundle.dailyReports.length + quietArtifacts.reportArtifacts;
             return {
                 scope,
                 mode: totalSourceCount > 0 ? "quiet" : "unknown",
                 sourceCount: totalSourceCount,
                 reportCount: totalReportCount,
                 recentJournalCount: bundle.journalEntries.length,
+                emptyStateCount: quietArtifacts.emptyStateArtifacts,
             };
         },
         async loadSession(sessionId) {

package/runtime/cli/read-models/types.d.ts

@@ -119,6 +119,7 @@ export interface QuietReadModel {
     sourceCount: number;
     reportCount: number;
     recentJournalCount: number;
+    emptyStateCount?: number;
 }
 export interface SessionDetailReadModel {
     requestedSessionId: string;

package/runtime/connectors/agent-network/agent-world/adapter.d.ts

@@ -6,6 +6,7 @@ export interface AgentWorldApiClient {
 }
 export declare function createAgentWorldRunner(input: {
     apiClient: AgentWorldApiClient;
+    apiKey?: string;
 }): {
     run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
 };

package/runtime/connectors/agent-network/agent-world/adapter.js

@@ -1,10 +1,10 @@
 export function createAgentWorldRunner(input) {
-    const { apiClient } = input;
+    const { apiClient, apiKey: configuredApiKey } = input;
     return {
         async run(plan, request) {
             const started = Date.now();
             try {
-                const apiKey = request.payload?.apiKey ?? "";
+                const apiKey = configuredApiKey ?? request.payload.apiKey ?? "";
                 if (!apiKey) {
                     return {
                         platformId: request.platformId,

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

@@ -3,7 +3,9 @@ import { type FailureClass } from "./failure-taxonomy.js";
 export declare const CHANNEL_TYPES: readonly ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
 export type ChannelType = (typeof CHANNEL_TYPES)[number];
 export declare const CAPABILITY_INTENTS: readonly ["feed.read", "post.publish", "comment.reply", "notification.list", "message.send", "agent.register", "agent.heartbeat", "work.discover", "task.claim"];
-export type CapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
+export type BuiltInCapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
+export type CapabilityIntent = BuiltInCapabilityIntent | (string & {});
+export declare function isKnownCapabilityIntent(intent: string): intent is BuiltInCapabilityIntent;
 export interface ConnectorRequest {
     platformId: string;
     intent: CapabilityIntent;
@@ -28,6 +30,7 @@ export interface ConnectorResult<T> {
     data?: T;
     failureClass?: FailureClass;
     retryAfterMs?: number;
+    executionId?: string;
     metadata: {
         platformId: string;
         channel: ChannelType;

package/runtime/connectors/base/contract.js

@@ -20,9 +20,13 @@ export const CAPABILITY_INTENTS = [
     "work.discover",
     "task.claim",
 ];
+export function isKnownCapabilityIntent(intent) {
+    return CAPABILITY_INTENTS.includes(intent);
+}
+const capabilityIntentSchema = z.string().min(1).regex(/^[a-zA-Z0-9_.:-]+$/);
 const connectorRequestSchema = z.object({
     platformId: z.string().min(1),
-    intent: z.enum(CAPABILITY_INTENTS),
+    intent: capabilityIntentSchema,
     payload: z.record(z.string(), z.unknown()),
     preferredChannel: z.enum(CHANNEL_TYPES).optional(),
     timeoutMs: z.number().int().positive().optional(),

package/runtime/connectors/base/effect-commit-ledger-sqlite.d.ts

@@ -0,0 +1,31 @@
+/**
+ * EffectCommitLedger SQLite implementation — T-CS.C.2
+ *
+ * Core logic: Persists effect-commit records to SQLite with idempotency-key
+ * uniqueness. On process restart, a previously committed key returns
+ * `{ existing: true, record: { ... } }`, enabling replay without side-effect.
+ *
+ * Implements `EffectCommitLedgerPort` from `./execution-policy.js`.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../storage/db/index.js`
+ * - `EffectCommitLedgerPort` from `./execution-policy.js`
+ *
+ * Boundary:
+ * - idempotency_key is UNIQUE; duplicate insert attempts are caught and
+ *   resolved to the existing record.
+ * - `markCommitted` is an extension beyond the port for use by execution
+ *   adapters to transition state from `planned`/`dispatched` to `committed`.
+ *
+ * Test coverage: tests/unit/connectors/effect-commit-ledger-sqlite.test.ts
+ */
+import type { StateDatabase } from "../../storage/db/index.js";
+import type { EffectCommitLedgerPort } from "./execution-policy.js";
+export interface EffectCommitLedgerSQLite extends EffectCommitLedgerPort {
+    /** Transition an existing record to committed with an outcome ref. */
+    markCommitted(idempotencyKey: string, outcomeRef: string): Promise<{
+        ok: boolean;
+        previousState?: string;
+    }>;
+}
+export declare function createEffectCommitLedgerSQLite(database: StateDatabase): EffectCommitLedgerSQLite;

package/runtime/connectors/base/effect-commit-ledger-sqlite.js

@@ -0,0 +1,86 @@
+/**
+ * EffectCommitLedger SQLite implementation — T-CS.C.2
+ *
+ * Core logic: Persists effect-commit records to SQLite with idempotency-key
+ * uniqueness. On process restart, a previously committed key returns
+ * `{ existing: true, record: { ... } }`, enabling replay without side-effect.
+ *
+ * Implements `EffectCommitLedgerPort` from `./execution-policy.js`.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../storage/db/index.js`
+ * - `EffectCommitLedgerPort` from `./execution-policy.js`
+ *
+ * Boundary:
+ * - idempotency_key is UNIQUE; duplicate insert attempts are caught and
+ *   resolved to the existing record.
+ * - `markCommitted` is an extension beyond the port for use by execution
+ *   adapters to transition state from `planned`/`dispatched` to `committed`.
+ *
+ * Test coverage: tests/unit/connectors/effect-commit-ledger-sqlite.test.ts
+ */
+import * as crypto from "node:crypto";
+export function createEffectCommitLedgerSQLite(database) {
+    const { sqlite } = database;
+    return {
+        async getOrCreateIntentCommitRecord(input) {
+            // Try insert first; if UNIQUE conflict, read existing
+            const commitId = crypto.randomUUID();
+            const createdAt = new Date().toISOString();
+            try {
+                sqlite.run(`INSERT INTO effect_commit_ledger
+           (commit_id, idempotency_key, decision_id, intent_id, effect_class, status, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                    commitId,
+                    input.idempotencyKey,
+                    input.decisionId,
+                    input.intentId,
+                    input.effectClass,
+                    "planned",
+                    createdAt,
+                ]);
+                return {
+                    existing: false,
+                    record: { id: commitId, state: "planned" },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // SQLite UNIQUE constraint violation codes: 2067 (SQLITE_CONSTRAINT_UNIQUE)
+                if (msg.includes("UNIQUE constraint failed") || msg.includes("constraint")) {
+                    const existingResult = sqlite.exec(`SELECT commit_id, status, outcome_ref
+             FROM effect_commit_ledger
+             WHERE idempotency_key = ?`, [input.idempotencyKey]);
+                    if (existingResult.length > 0 &&
+                        existingResult[0].values.length > 0) {
+                        const cols = existingResult[0].columns;
+                        const row = existingResult[0].values[0];
+                        const get = (name) => row[cols.indexOf(name)];
+                        return {
+                            existing: true,
+                            record: {
+                                id: get("commit_id"),
+                                state: get("status"),
+                                outcomeRef: get("outcome_ref") ?? undefined,
+                            },
+                        };
+                    }
+                }
+                throw err;
+            }
+        },
+        async markCommitted(idempotencyKey, outcomeRef) {
+            const currentResult = sqlite.exec(`SELECT status FROM effect_commit_ledger WHERE idempotency_key = ?`, [idempotencyKey]);
+            if (currentResult.length === 0 ||
+                currentResult[0].values.length === 0) {
+                return { ok: false };
+            }
+            const previousState = currentResult[0].values[0][0];
+            const committedAt = new Date().toISOString();
+            sqlite.run(`UPDATE effect_commit_ledger
+         SET status = ?, outcome_ref = ?, committed_at = ?
+         WHERE idempotency_key = ?`, ["committed", outcomeRef, committedAt, idempotencyKey]);
+            return { ok: true, previousState };
+        },
+    };
+}

package/runtime/connectors/base/failure-taxonomy.js

@@ -118,6 +118,11 @@ export function classifyFailure(error) {
                     class: "permanent_input_error",
                     retryable: RETRYABLE_BY_CLASS.permanent_input_error,
                 };
+            if (code === "unknown_platform" || code === "unknown_platform_change")
+                return {
+                    class: "unknown_platform_change",
+                    retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
+                };
         }
         const status = record.status;
         if (status === 429) {

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

@@ -0,0 +1,151 @@
+/**
+ * Manifest v7 Schema + CapabilityContractRegistry v7 Extension — T-CS.C.1
+ *
+ * Core logic: Extends v6 manifest with v7 fields:
+ * - `probeConfig` (safeEndpoint, idempotencyClass)
+ * - `endpointMappings` (profilePath, claimPath, heartbeatPath)
+ * - `capabilityId` per capability (DR-001 fix)
+ *
+ * Zod strict validation with detailed error messages on registration failure.
+ *
+ * Dependencies:
+ * - Zod for schema validation
+ * - v6 `CapabilityContractRegistry` from `./manifest.js` as baseline
+ *
+ * Boundary:
+ * - `ConnectorManifestV7` is a superset of v6 manifest fields.
+ * - `CapabilityContractRegistryV7` wraps/extends the base registry with
+ *   v7-specific lookups (`resolveCapabilityV7`, `getProbeConfig`,
+ *   `getEndpointMapping`).
+ * - Registration failures return `{ ok: false; errors: string[] }` instead of
+ *   throwing.
+ *
+ * Test coverage: tests/unit/connectors/manifest-v7-schema.test.ts
+ */
+import { z } from "zod";
+export declare const IdempotencyClassSchema: z.ZodEnum<{
+    strict: "strict";
+    read_only: "read_only";
+    idempotent_write: "idempotent_write";
+}>;
+export type IdempotencyClass = z.infer<typeof IdempotencyClassSchema>;
+export declare const ProbeConfigSchema: z.ZodObject<{
+    safeEndpoint: z.ZodString;
+    idempotencyClass: z.ZodEnum<{
+        strict: "strict";
+        read_only: "read_only";
+        idempotent_write: "idempotent_write";
+    }>;
+}, z.core.$strip>;
+export type ProbeConfig = z.infer<typeof ProbeConfigSchema>;
+export declare const EndpointMappingsSchema: z.ZodObject<{
+    profilePath: z.ZodOptional<z.ZodString>;
+    claimPath: z.ZodOptional<z.ZodString>;
+    heartbeatPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EndpointMappings = z.infer<typeof EndpointMappingsSchema>;
+export declare const V7CapabilitySchema: z.ZodObject<{
+    capabilityId: z.ZodString;
+    intent: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    probeConfig: z.ZodOptional<z.ZodObject<{
+        safeEndpoint: z.ZodString;
+        idempotencyClass: z.ZodEnum<{
+            strict: "strict";
+            read_only: "read_only";
+            idempotent_write: "idempotent_write";
+        }>;
+    }, z.core.$strip>>;
+    endpointMappings: z.ZodOptional<z.ZodObject<{
+        profilePath: z.ZodOptional<z.ZodString>;
+        claimPath: z.ZodOptional<z.ZodString>;
+        heartbeatPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type V7Capability = z.infer<typeof V7CapabilitySchema>;
+export declare const ConnectorManifestV7Schema: z.ZodObject<{
+    platformId: z.ZodString;
+    capabilities: z.ZodArray<z.ZodObject<{
+        capabilityId: z.ZodString;
+        intent: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        probeConfig: z.ZodOptional<z.ZodObject<{
+            safeEndpoint: z.ZodString;
+            idempotencyClass: z.ZodEnum<{
+                strict: "strict";
+                read_only: "read_only";
+                idempotent_write: "idempotent_write";
+            }>;
+        }, z.core.$strip>>;
+        endpointMappings: z.ZodOptional<z.ZodObject<{
+            profilePath: z.ZodOptional<z.ZodString>;
+            claimPath: z.ZodOptional<z.ZodString>;
+            heartbeatPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    channelPriority: z.ZodArray<z.ZodString>;
+    credentialTypes: z.ZodArray<z.ZodString>;
+    probeConfig: z.ZodOptional<z.ZodObject<{
+        safeEndpoint: z.ZodString;
+        idempotencyClass: z.ZodEnum<{
+            strict: "strict";
+            read_only: "read_only";
+            idempotent_write: "idempotent_write";
+        }>;
+    }, z.core.$strip>>;
+    endpointMappings: z.ZodOptional<z.ZodObject<{
+        profilePath: z.ZodOptional<z.ZodString>;
+        claimPath: z.ZodOptional<z.ZodString>;
+        heartbeatPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    degradedChannels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sourceRefPolicy: z.ZodOptional<z.ZodObject<{
+        minSourceRefs: z.ZodOptional<z.ZodNumber>;
+        rejectInlineSensitivePayload: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConnectorManifestV7 = z.infer<typeof ConnectorManifestV7Schema>;
+export interface ManifestValidationResult {
+    ok: boolean;
+    errors: string[];
+    manifest?: ConnectorManifestV7;
+}
+/**
+ * Parse and validate a v7 manifest object.
+ * Returns detailed errors rather than throwing.
+ */
+export declare function validateManifestV7(input: unknown): ManifestValidationResult;
+export interface ResolvedV7Capability {
+    platformId: string;
+    capabilityId: string;
+    intent: string;
+    probeConfig?: ProbeConfig;
+    endpointMappings?: EndpointMappings;
+}
+export declare class CapabilityContractRegistryV7 {
+    private readonly byPlatform;
+    /**
+     * Register a v7 manifest.
+     * Returns `{ ok: false, errors }` on validation failure;
+     * never throws for validation errors.
+     */
+    register(manifest: unknown): ManifestValidationResult;
+    loadManifest(platformId: string): ConnectorManifestV7 | undefined;
+    listRegisteredPlatformIds(): string[];
+    /**
+     * Resolve a capability by its `capabilityId` (namespace optional).
+     * Supports `platformId:capabilityId` qualified form.
+     */
+    resolveCapability(capabilityIdOrQualified: string): ResolvedV7Capability | undefined;
+    private _resolveOnPlatform;
+    getProbeConfig(platformId: string, capabilityId: string): ProbeConfig | undefined;
+    getEndpointMappings(platformId: string, capabilityId: string): EndpointMappings | undefined;
+    hasCapability(platformId: string, capabilityId: string): boolean;
+    listCapabilities(platformId: string): Array<{
+        capabilityId: string;
+        intent: string;
+        hasProbeConfig: boolean;
+        hasEndpointMappings: boolean;
+    }>;
+}
+export { ConnectorManifestV7Schema as ManifestV7Schema };

package/runtime/connectors/base/manifest-v7.js

@@ -0,0 +1,170 @@
+/**
+ * Manifest v7 Schema + CapabilityContractRegistry v7 Extension — T-CS.C.1
+ *
+ * Core logic: Extends v6 manifest with v7 fields:
+ * - `probeConfig` (safeEndpoint, idempotencyClass)
+ * - `endpointMappings` (profilePath, claimPath, heartbeatPath)
+ * - `capabilityId` per capability (DR-001 fix)
+ *
+ * Zod strict validation with detailed error messages on registration failure.
+ *
+ * Dependencies:
+ * - Zod for schema validation
+ * - v6 `CapabilityContractRegistry` from `./manifest.js` as baseline
+ *
+ * Boundary:
+ * - `ConnectorManifestV7` is a superset of v6 manifest fields.
+ * - `CapabilityContractRegistryV7` wraps/extends the base registry with
+ *   v7-specific lookups (`resolveCapabilityV7`, `getProbeConfig`,
+ *   `getEndpointMapping`).
+ * - Registration failures return `{ ok: false; errors: string[] }` instead of
+ *   throwing.
+ *
+ * Test coverage: tests/unit/connectors/manifest-v7-schema.test.ts
+ */
+import { z } from "zod";
+// ─── V7 Capability Schema ───────────────────────────────────────────────────
+export const IdempotencyClassSchema = z.enum([
+    "read_only",
+    "idempotent_write",
+    "strict",
+]);
+export const ProbeConfigSchema = z.object({
+    safeEndpoint: z.string().min(1),
+    idempotencyClass: IdempotencyClassSchema,
+});
+export const EndpointMappingsSchema = z.object({
+    profilePath: z.string().min(1).optional(),
+    claimPath: z.string().min(1).optional(),
+    heartbeatPath: z.string().min(1).optional(),
+});
+export const V7CapabilitySchema = z.object({
+    capabilityId: z.string().min(1),
+    intent: z.string().min(1).regex(/^[a-zA-Z0-9_.:-]+$/),
+    description: z.string().optional(),
+    probeConfig: ProbeConfigSchema.optional(),
+    endpointMappings: EndpointMappingsSchema.optional(),
+});
+// ─── V7 Manifest Schema ─────────────────────────────────────────────────────
+export const ConnectorManifestV7Schema = z.object({
+    platformId: z.string().min(1),
+    capabilities: z.array(V7CapabilitySchema).min(1),
+    channelPriority: z.array(z.string().min(1)).min(1),
+    credentialTypes: z.array(z.string().min(1)).min(1),
+    probeConfig: ProbeConfigSchema.optional(),
+    endpointMappings: EndpointMappingsSchema.optional(),
+    degradedChannels: z.array(z.string().min(1)).optional(),
+    sourceRefPolicy: z
+        .object({
+        minSourceRefs: z.number().int().min(0).optional(),
+        rejectInlineSensitivePayload: z.boolean().optional(),
+    })
+        .optional(),
+});
+/**
+ * Parse and validate a v7 manifest object.
+ * Returns detailed errors rather than throwing.
+ */
+export function validateManifestV7(input) {
+    const parsed = ConnectorManifestV7Schema.safeParse(input);
+    if (!parsed.success) {
+        const errors = parsed.error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`);
+        return { ok: false, errors };
+    }
+    return { ok: true, errors: [], manifest: parsed.data };
+}
+export class CapabilityContractRegistryV7 {
+    byPlatform = new Map();
+    /**
+     * Register a v7 manifest.
+     * Returns `{ ok: false, errors }` on validation failure;
+     * never throws for validation errors.
+     */
+    register(manifest) {
+        const validation = validateManifestV7(manifest);
+        if (!validation.ok) {
+            return validation;
+        }
+        const parsed = validation.manifest;
+        // DR-001: capabilityId must be present on every capability
+        const missingIds = [];
+        for (const cap of parsed.capabilities) {
+            if (!cap.capabilityId || cap.capabilityId.trim().length === 0) {
+                missingIds.push(cap.intent);
+            }
+        }
+        if (missingIds.length > 0) {
+            return {
+                ok: false,
+                errors: missingIds.map((intent) => `capabilities: capabilityId missing for intent "${intent}"`),
+            };
+        }
+        this.byPlatform.set(parsed.platformId, parsed);
+        return { ok: true, errors: [] };
+    }
+    loadManifest(platformId) {
+        return this.byPlatform.get(platformId);
+    }
+    listRegisteredPlatformIds() {
+        return [...this.byPlatform.keys()];
+    }
+    /**
+     * Resolve a capability by its `capabilityId` (namespace optional).
+     * Supports `platformId:capabilityId` qualified form.
+     */
+    resolveCapability(capabilityIdOrQualified) {
+        const colonIndex = capabilityIdOrQualified.indexOf(":");
+        if (colonIndex >= 0) {
+            const platformId = capabilityIdOrQualified.slice(0, colonIndex);
+            const capabilityId = capabilityIdOrQualified.slice(colonIndex + 1);
+            return this._resolveOnPlatform(platformId, capabilityId);
+        }
+        // Search all platforms for first matching capabilityId
+        for (const platformId of this.byPlatform.keys()) {
+            const found = this._resolveOnPlatform(platformId, capabilityIdOrQualified);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    _resolveOnPlatform(platformId, capabilityIdOrIntent) {
+        const manifest = this.byPlatform.get(platformId);
+        if (!manifest)
+            return undefined;
+        // Match by capabilityId (exact) or intent (fallback)
+        const cap = manifest.capabilities.find((c) => c.capabilityId === capabilityIdOrIntent) ??
+            manifest.capabilities.find((c) => c.intent === capabilityIdOrIntent);
+        if (!cap)
+            return undefined;
+        return {
+            platformId,
+            capabilityId: cap.capabilityId,
+            intent: cap.intent,
+            probeConfig: cap.probeConfig ?? manifest.probeConfig,
+            endpointMappings: cap.endpointMappings ?? manifest.endpointMappings,
+        };
+    }
+    getProbeConfig(platformId, capabilityId) {
+        const resolved = this._resolveOnPlatform(platformId, capabilityId);
+        return resolved?.probeConfig;
+    }
+    getEndpointMappings(platformId, capabilityId) {
+        const resolved = this._resolveOnPlatform(platformId, capabilityId);
+        return resolved?.endpointMappings;
+    }
+    hasCapability(platformId, capabilityId) {
+        return this._resolveOnPlatform(platformId, capabilityId) !== undefined;
+    }
+    listCapabilities(platformId) {
+        const manifest = this.byPlatform.get(platformId);
+        if (!manifest)
+            return [];
+        return manifest.capabilities.map((cap) => ({
+            capabilityId: cap.capabilityId,
+            intent: cap.intent,
+            hasProbeConfig: !!cap.probeConfig || !!manifest.probeConfig,
+            hasEndpointMappings: !!cap.endpointMappings || !!manifest.endpointMappings,
+        }));
+    }
+}
+export { ConnectorManifestV7Schema as ManifestV7Schema };