@withpica/mcp-server 1.3.0

package/dist/tools/recordings.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Recordings Tools — MCP tools for managing recordings.
+ *
+ * ADR-149 Phase 5b: Consolidated to query+inspect pattern.
+ * - pica_recordings_query replaces pica_recordings_list + pica_recordings_by_work
+ * - pica_recordings_inspect replaces pica_recordings_get (with sections support)
+ *
+ * ADR-174 Phase 2 item 3 reconciliation: the write surface covers only
+ * real columns on `public.recordings`. Phantom fields previously
+ * accepted via `additionalProperties: true` are gone; agents that
+ * tried to set them silently dropped data on the way to Postgres.
+ *
+ * Two pre-flight surprises documented inline below:
+ *
+ *   1. `title` is a legacy alias for `recording_title`. The HTTP route
+ *      translates before the service sees the payload (POST since the
+ *      route was written, PATCH only since ADR-174). The tool keeps
+ *      `title` as the input field name for caller ergonomics; the
+ *      description marks the rename explicitly.
+ *
+ *   2. Duration lives in `duration_ms` on recordings (works carry
+ *      `duration_seconds`). Agents conflating the two get a 400 with
+ *      a redirect from the route allow-list.
+ *
+ * Add-candidates surfaced per the audit at
+ * docs/audits/2026-04-14-mcp-db-reconciliation.md §3:
+ *   duration_ms, preview_url, album_art_url, spotify_url,
+ *   spotify_track_uri, spotify_track_id, youtube_video_id, youtube_url,
+ *   apple_music_url, deezer_track_id, mlc_recording_id, mlc_song_code.
+ *
+ * Most of these are populated by the enrichment cascade on streaming
+ * import; exposing them lets agents seed or override that data
+ * deliberately rather than discovering — surprised — that the field
+ * they thought they set was silently absent.
+ *
+ * `isrc_prefix` is intentionally NOT in this set — column is GENERATED
+ * ALWAYS in `public.recordings` (left(replace(isrc,'-',''),5)). Caught
+ * by ADR-198 Phase 1 contract — every write attempt 500'd with PG
+ * 428C9 "cannot insert non-DEFAULT value into generated column".
+ */
+import { PicaClient } from "@withpica/mcp-sdk";
+import { ToolDefinition, ToolExecutor } from "./index.js";
+/**
+ * Canonical write-schema for `recordings`. Every property must
+ * correspond to a real column on `public.recordings` (or be the
+ * documented `title` legacy alias) — verified against
+ * `lib/db/database.types.ts`. The HTTP route at
+ * `app/api/admin/recordings/route.ts` carries the same allow-list
+ * (plus the `recording_type` legacy alias for non-MCP callers); this
+ * list is the narrower MCP-agent contract.
+ *
+ * `version_type` is enum-restricted by the
+ * `recordings_version_type_check` CHECK constraint (ADR-166 Phase 1).
+ * Reflecting the enum here means agents see invalid values as schema
+ * errors at the tool surface, not as 500s round-tripped from Postgres.
+ */
+declare const RECORDING_WRITE_PROPERTIES: Record<string, Record<string, unknown>>;
+export declare class RecordingsTools {
+    private pica;
+    constructor(pica: PicaClient);
+    /**
+     * Get all recordings tools
+     */
+    getTools(): Array<{
+        definition: ToolDefinition;
+        executor: ToolExecutor;
+    }>;
+    /**
+     * Query recordings — list all, search by text, or filter by work
+     */
+    private queryRecordings;
+    /**
+     * Inspect a recording — get details with optional section filtering
+     */
+    private inspectRecording;
+    /**
+     * Create recording.
+     *
+     * `version_type` defaults to 'master' (the DB-level default and the
+     * canonical ADR-166 value). Pre-ADR-174 the executor defaulted to
+     * 'original', which is not a valid version_type — every call without
+     * an explicit type tripped the recording-type CHECK constraint and
+     * surfaced as a 500 from the service.
+     */
+    private createRecording;
+    /**
+     * Update recording
+     */
+    private updateRecording;
+    /**
+     * Delete recording
+     */
+    private deleteRecording;
+}
+export { RECORDING_WRITE_PROPERTIES };
+//# sourceMappingURL=recordings.d.ts.map

package/dist/tools/recordings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordings.d.ts","sourceRoot":"","sources":["../../src/tools/recordings.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAAE,UAAU,EAAuB,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAc,MAAM,YAAY,CAAC;AAYtE;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA6IvE,CAAC;AAEF,qBAAa,eAAe;IAC1B,OAAO,CAAC,IAAI,CAAa;gBAEb,IAAI,EAAE,UAAU;IAI5B;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC;QAAE,UAAU,EAAE,cAAc,CAAC;QAAC,QAAQ,EAAE,YAAY,CAAA;KAAE,CAAC;IAiJzE;;OAEG;YACW,eAAe;IAkC7B;;OAEG;YACW,gBAAgB;IAiL9B;;;;;;;;OAQG;YACW,eAAe;IAgB7B;;OAEG;YACW,eAAe;IAW7B;;OAEG;YACW,eAAe;CAM9B;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/tools/recordings.js

@@ -0,0 +1,564 @@
+// Copyright (c) 2024-2026 Withpica Ltd. All rights reserved.
+/**
+ * Recordings Tools — MCP tools for managing recordings.
+ *
+ * ADR-149 Phase 5b: Consolidated to query+inspect pattern.
+ * - pica_recordings_query replaces pica_recordings_list + pica_recordings_by_work
+ * - pica_recordings_inspect replaces pica_recordings_get (with sections support)
+ *
+ * ADR-174 Phase 2 item 3 reconciliation: the write surface covers only
+ * real columns on `public.recordings`. Phantom fields previously
+ * accepted via `additionalProperties: true` are gone; agents that
+ * tried to set them silently dropped data on the way to Postgres.
+ *
+ * Two pre-flight surprises documented inline below:
+ *
+ *   1. `title` is a legacy alias for `recording_title`. The HTTP route
+ *      translates before the service sees the payload (POST since the
+ *      route was written, PATCH only since ADR-174). The tool keeps
+ *      `title` as the input field name for caller ergonomics; the
+ *      description marks the rename explicitly.
+ *
+ *   2. Duration lives in `duration_ms` on recordings (works carry
+ *      `duration_seconds`). Agents conflating the two get a 400 with
+ *      a redirect from the route allow-list.
+ *
+ * Add-candidates surfaced per the audit at
+ * docs/audits/2026-04-14-mcp-db-reconciliation.md §3:
+ *   duration_ms, preview_url, album_art_url, spotify_url,
+ *   spotify_track_uri, spotify_track_id, youtube_video_id, youtube_url,
+ *   apple_music_url, deezer_track_id, mlc_recording_id, mlc_song_code.
+ *
+ * Most of these are populated by the enrichment cascade on streaming
+ * import; exposing them lets agents seed or override that data
+ * deliberately rather than discovering — surprised — that the field
+ * they thought they set was silently absent.
+ *
+ * `isrc_prefix` is intentionally NOT in this set — column is GENERATED
+ * ALWAYS in `public.recordings` (left(replace(isrc,'-',''),5)). Caught
+ * by ADR-198 Phase 1 contract — every write attempt 500'd with PG
+ * 428C9 "cannot insert non-DEFAULT value into generated column".
+ */
+import { EntityNotFoundError } from "@withpica/mcp-sdk";
+import { formatSuccess, formatStructuredList, withBillingGate, pushSectionError, } from "@withpica/mcp-utils";
+import { buildRecordingAttributionHints } from "./recording-attribution-hints.js";
+/**
+ * Canonical write-schema for `recordings`. Every property must
+ * correspond to a real column on `public.recordings` (or be the
+ * documented `title` legacy alias) — verified against
+ * `lib/db/database.types.ts`. The HTTP route at
+ * `app/api/admin/recordings/route.ts` carries the same allow-list
+ * (plus the `recording_type` legacy alias for non-MCP callers); this
+ * list is the narrower MCP-agent contract.
+ *
+ * `version_type` is enum-restricted by the
+ * `recordings_version_type_check` CHECK constraint (ADR-166 Phase 1).
+ * Reflecting the enum here means agents see invalid values as schema
+ * errors at the tool surface, not as 500s round-tripped from Postgres.
+ */
+const RECORDING_WRITE_PROPERTIES = {
+    // Core (legacy `title` alias — translated to `recording_title` by the
+    // HTTP route; included here so agents don't have to know the rename).
+    title: {
+        type: "string",
+        description: "Recording title. Legacy alias — the HTTP route translates this to the canonical `recording_title` column. Either field is accepted; pass `title` for ergonomics.",
+    },
+    recording_title: {
+        type: "string",
+        description: "Recording title (canonical column name).",
+    },
+    artist_name: {
+        type: "string",
+        description: "Artist name for this recording",
+    },
+    version_type: {
+        type: "string",
+        description: "Recording version type. Defaults to 'master' on create. Enforced by DB CHECK constraint.",
+        enum: [
+            "master",
+            "alternate_master",
+            "music_video",
+            "lyric_video",
+            "live_performance",
+            "acoustic",
+            "remix",
+            "cover",
+            "alternate",
+        ],
+    },
+    work_id: {
+        type: "string",
+        description: "ID of the work this recording is of (FK to works). A bad UUID returns 400 RECORDING_FK_VIOLATION — call pica_works_query first to resolve a title to an ID.",
+    },
+    ownership_percentage: {
+        type: "number",
+        description: "Ownership percentage (0–100, validated server-side)",
+    },
+    labels: {
+        type: "string",
+        description: "Record label(s) as freetext. Legacy column — the structured home is `global_recording_labels` (not yet exposed via MCP).",
+    },
+    // Identifiers
+    isrc: {
+        type: "string",
+        description: "International Standard Recording Code (e.g. GBUM71804829). Triggers global_recordings linking on create/update.",
+    },
+    isrc_source: {
+        type: "string",
+        description: "Where the ISRC came from (e.g. 'spotify', 'mlc', 'manual', 'ppl', 'apple_music', 'youtube_music', 'soundcloud', 'disco').",
+    },
+    musicbrainz_recording_id: {
+        type: "string",
+        description: "MusicBrainz recording UUID",
+    },
+    mlc_recording_id: {
+        type: "string",
+        description: "MLC recording ID",
+    },
+    mlc_song_code: {
+        type: "string",
+        description: "MLC song code (links recording to its work registration)",
+    },
+    // Master metadata (ADR-165 Phase 2 — populated by enrichment but
+    // settable from MCP for manual seeding/overrides).
+    duration_ms: {
+        type: "number",
+        description: "Duration in milliseconds. Note: `works` carries duration_seconds; `recordings` carries duration_ms.",
+    },
+    preview_url: {
+        type: "string",
+        description: "30-second preview URL (Spotify or equivalent)",
+    },
+    album_art_url: {
+        type: "string",
+        description: "Denormalised album artwork URL. Source of truth is releases.artwork_url; duplicated here for catalogue-card hot paths.",
+    },
+    spotify_url: {
+        type: "string",
+        description: "Per-track Spotify URL (e.g. https://open.spotify.com/track/...). Distinct from releases.spotify_url which is the album-level URL.",
+    },
+    spotify_track_uri: {
+        type: "string",
+        description: "spotify:track:{id} URI for the master. Distinct from release_tracks.spotify_track_uri (per-track-in-release).",
+    },
+    spotify_track_id: {
+        type: "string",
+        description: "Spotify external track id (for dedup + cascade matching)",
+    },
+    youtube_video_id: {
+        type: "string",
+        description: "YouTube video id. Non-master version types (music_video, lyric_video, etc.) get their own video id.",
+    },
+    youtube_url: {
+        type: "string",
+        description: "YouTube watch URL",
+    },
+    apple_music_url: {
+        type: "string",
+        description: "Apple Music track URL",
+    },
+    deezer_track_id: {
+        type: "string",
+        description: "Deezer track id",
+    },
+    // PPL
+    ppl_registered: {
+        type: "boolean",
+        description: "Whether registered with PPL",
+    },
+    ppl_recording_id: {
+        type: "string",
+        description: "PPL recording ID",
+    },
+    // Declared jsonb extension points
+    ai_disclosure: {
+        type: "object",
+        description: "AI disclosure object (UK AI Copyright compliance). Fields: composition, performance, production, mastering ('none'|'assisted'|'generated'), tools_used (string[]), disclosure_date, disclosed_by.",
+    },
+    provenance_attestation: {
+        type: "object",
+        description: "Human creation proof. Fields: human_created (bool), attested_by, attested_at, attestation_method, supporting_evidence, ip_address, signature_hash, certificate_id.",
+    },
+    training_rights: {
+        type: "object",
+        description: "B2B ML licensing compliance object. Fields: available_for_training (bool), training_terms, minimum_fee, excluded_uses, permitted_uses, geographic_restrictions, requires_attribution, requires_notification, license_duration, updated_at, updated_by.",
+    },
+};
+export class RecordingsTools {
+    pica;
+    constructor(pica) {
+        this.pica = pica;
+    }
+    /**
+     * Get all recordings tools
+     */
+    getTools() {
+        return [
+            {
+                definition: {
+                    name: "pica_recordings_query",
+                    description: "Find recordings — list all, search by query, or filter by work. " +
+                        "→ then: pica_recordings_inspect (details for a specific recording)",
+                    workflows: "infrastructure",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: {
+                                type: "string",
+                                description: "Search by title, ISRC, or artist name",
+                            },
+                            work_id: {
+                                type: "string",
+                                description: "Filter recordings by work ID (replaces pica_recordings_by_work)",
+                            },
+                            limit: {
+                                type: "number",
+                                description: "Max results (default: 50)",
+                            },
+                        },
+                    },
+                },
+                executor: this.queryRecordings.bind(this),
+            },
+            {
+                definition: {
+                    name: "pica_recordings_inspect",
+                    description: "Get details for a specific recording. Omit sections for everything. " +
+                        "Sections: basic (recording row + ISRC prefix intel), credits (work-side credits via parent work), recording_credits (first-party operator-authored production credits on this recording), audio (audio files via parent work), production_assets, releases. " +
+                        "Round-trip a pica_recording_credits_update write via sections:['recording_credits']. " +
+                        "→ then: pica_audio_query (audio files), pica_credits_update (fix work-side credits), pica_recording_credits_update (add a recording-side credit)",
+                    workflows: "infrastructure",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "Recording ID",
+                            },
+                            sections: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                    enum: [
+                                        "basic",
+                                        "credits",
+                                        "recording_credits",
+                                        "audio",
+                                        "production_assets",
+                                        "releases",
+                                    ],
+                                },
+                                description: 'Which data sections to include. Omit for all sections. Use ["basic"] for lightweight lookup. Use ["recording_credits"] to round-trip a pica_recording_credits_update write.',
+                            },
+                        },
+                        required: ["id"],
+                    },
+                },
+                executor: this.inspectRecording.bind(this),
+            },
+            {
+                definition: {
+                    name: "pica_recordings_create",
+                    description: "Create a new recording. IMPORTANT: call pica_recordings_query with work_id first to check for existing recordings on the same work — duplicate masters cause ISRC conflicts. " +
+                        "Album metadata (album_name, album_release_date, upc, track_number) lives on pica_releases_create/update, not here. " +
+                        "Label-as-org belongs on the release (pica_releases_*.label_organization_id via pica_labels_query); the legacy `labels` freetext column is kept for backwards compat. " +
+                        "ISWCs identify works, not recordings — set them via pica_works_create/update. " +
+                        "Duration is in milliseconds (`duration_ms`); the `duration_seconds` works convention is rejected with a 400. " +
+                        "After several mutations, surface a pica_dashboard_briefing to the user. " +
+                        "→ before: pica_recordings_query (check duplicates) → then: pica_audio_presigned_upload (upload audio), pica_audio_analyze (extract features)",
+                    workflows: ["recording-required"],
+                    inputSchema: {
+                        type: "object",
+                        properties: RECORDING_WRITE_PROPERTIES,
+                        required: ["title", "artist_name", "version_type"],
+                    },
+                },
+                executor: withBillingGate(this.pica, "recording creation", this.createRecording.bind(this)),
+            },
+            {
+                definition: {
+                    name: "pica_recordings_update",
+                    description: "Update an existing recording. Only real `recordings` columns are accepted. " +
+                        "Album metadata (album_name, upc, track_number) belongs on pica_releases_create/update; ISWC belongs on pica_works_create/update; duration is in `duration_ms` (not `duration_seconds`). " +
+                        "Bad keys return a 400 with a redirect message naming the correct tool. " +
+                        "→ then: pica_recordings_inspect (verify changes persisted)",
+                    workflows: ["recording-required"],
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "Recording ID (required)",
+                            },
+                            ...RECORDING_WRITE_PROPERTIES,
+                        },
+                        required: ["id"],
+                    },
+                },
+                executor: withBillingGate(this.pica, "recording update", this.updateRecording.bind(this)),
+            },
+            {
+                definition: {
+                    name: "pica_recordings_delete",
+                    description: "Delete a recording (destructive — unlinks from release tracks and work).",
+                    workflows: "infrastructure",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "Recording ID",
+                            },
+                        },
+                        required: ["id"],
+                    },
+                },
+                executor: withBillingGate(this.pica, "recording deletion", this.deleteRecording.bind(this)),
+            },
+        ];
+    }
+    /**
+     * Query recordings — list all, search by text, or filter by work
+     */
+    async queryRecordings(args) {
+        const limit = args.limit || 50;
+        const workId = args.work_id;
+        const query = args.query;
+        // Filter by work_id — delegate to getByWork
+        if (workId) {
+            const recordings = await this.pica.recordings.getByWork(workId);
+            return formatStructuredList(recordings, "recording", {
+                work_id: workId,
+                total: recordings.length,
+            });
+        }
+        // Search by text query — delegate to search method (client-side filtering)
+        if (query) {
+            const result = await this.pica.recordings.search({ query, limit });
+            return formatStructuredList(result.data, "recording", {
+                query,
+                total: result.total,
+                hasMore: result.hasMore,
+            });
+        }
+        // Default: list all
+        const recordings = await this.pica.recordings.list({ limit });
+        return formatStructuredList(recordings, "recording", {
+            total: recordings.length,
+            limit,
+        });
+    }
+    /**
+     * Inspect a recording — get details with optional section filtering
+     */
+    async inspectRecording(args) {
+        const id = args.id;
+        const sections = args.sections;
+        const allSections = !sections || sections.length === 0;
+        const result = {};
+        // ADR-224 — see works.ts for the doctrine. recordings_inspect's
+        // pre-conversion pattern was the sibling-field shape (`result.X = []`
+        // + `result.X_error = msg`), the medium-severity variant of the four
+        // ADR-224 found. Flag-off mode preserves the sibling-field shape;
+        // flag-on drops the sibling fields and routes failures through
+        // errors[]. Primary-entity EntityNotFoundError propagation (PR #110,
+        // 2026-04-26) is preserved unchanged in both modes — that's a hard
+        // error signal that doesn't go through the section-error path.
+        const useStructured = process.env.ADR_224_STRUCTURED_ERRORS === "1";
+        const errors = [];
+        const TOOL_NAME = "pica_recordings_inspect";
+        // Basic section: recording details + ISRC prefix intel
+        if (allSections || sections?.includes("basic")) {
+            try {
+                const recording = await this.pica.recordings.get(id);
+                result.recording = recording;
+                // Enrich with ISRC prefix intelligence if ISRC is present
+                if (recording.isrc) {
+                    const prefixIntel = await this.pica.recordings.prefixLookup(recording.isrc);
+                    if (prefixIntel) {
+                        result.prefix_intel = prefixIntel;
+                    }
+                }
+            }
+            catch (error) {
+                // 404 on the primary entity is a hard error — propagate so the
+                // agent sees an explicit not-found signal instead of a 200 with
+                // a partial-empty payload (ADR-198 verification 2026-04-26 —
+                // pica_recordings_inspect was hallucinating into the void on
+                // missing route handlers / missing recordings). This propagation
+                // predates and is independent of ADR-224 — kept unchanged.
+                if (error instanceof EntityNotFoundError) {
+                    throw error;
+                }
+                if (!useStructured) {
+                    result.recording_error =
+                        error instanceof Error
+                            ? error.message
+                            : "Failed to fetch recording";
+                }
+                pushSectionError(errors, TOOL_NAME, "basic", error, id);
+            }
+        }
+        // Credits section: work credits (via recording's parent work)
+        if (allSections || sections?.includes("credits")) {
+            try {
+                // We need the recording to get its work_id
+                const recording = result.recording ||
+                    (await this.pica.recordings.get(id));
+                const workId = recording.work_id;
+                if (workId) {
+                    const credits = await this.pica.credits.listForWork(workId);
+                    result.credits = credits;
+                }
+                else {
+                    result.credits = [];
+                    result.credits_note = "No parent work linked — no credits available";
+                }
+            }
+            catch (error) {
+                if (!useStructured) {
+                    result.credits_error =
+                        error instanceof Error ? error.message : "Failed to fetch credits";
+                }
+                else {
+                    result.credits = null;
+                }
+                pushSectionError(errors, TOOL_NAME, "credits", error, id);
+            }
+        }
+        // ADR-213 Primitive A.1 — additive recording_credits section.
+        // Distinct from the `credits` section above (which reads work-side
+        // credits via the parent work). This reads first-party operator-
+        // authored production credits directly from the recording_credits
+        // table. Closes the round-trip path for pica_recording_credits_update
+        // per ADR-198. Trade-secret separation: this never touches the
+        // enrichment-cascade-fed `credits` table (per ip-protection.md).
+        if (allSections || sections?.includes("recording_credits")) {
+            try {
+                result.recording_credits = await this.pica.recordingCredits.list(id);
+            }
+            catch (error) {
+                if (!useStructured) {
+                    result.recording_credits = [];
+                    result.recording_credits_error =
+                        error instanceof Error
+                            ? error.message
+                            : "Failed to fetch recording_credits";
+                }
+                else {
+                    result.recording_credits = null;
+                }
+                pushSectionError(errors, TOOL_NAME, "recording_credits", error, id);
+            }
+        }
+        // Audio section: audio files linked to the parent work
+        if (allSections || sections?.includes("audio")) {
+            try {
+                const recording = result.recording ||
+                    (await this.pica.recordings.get(id));
+                const workId = recording.work_id;
+                if (workId) {
+                    const audioFiles = await this.pica.audioFiles.list({
+                        work_id: workId,
+                    });
+                    result.audio_files = audioFiles;
+                }
+                else {
+                    result.audio_files = [];
+                    result.audio_note =
+                        "No parent work linked — no audio files available";
+                }
+            }
+            catch (error) {
+                if (!useStructured) {
+                    result.audio_error =
+                        error instanceof Error
+                            ? error.message
+                            : "Failed to fetch audio files";
+                }
+                else {
+                    result.audio_files = null;
+                }
+                pushSectionError(errors, TOOL_NAME, "audio", error, id);
+            }
+        }
+        // ADR-156 op #3 Session B Task 5 — surface linked physical assets
+        // so the inspect tool is discoverable from the recording side.
+        if (allSections || sections?.includes("production_assets")) {
+            try {
+                result.production_assets =
+                    await this.pica.recordings.listProductionAssets(id);
+            }
+            catch (error) {
+                if (!useStructured) {
+                    result.production_assets = [];
+                    result.production_assets_error =
+                        error instanceof Error
+                            ? error.message
+                            : "Failed to fetch production assets";
+                }
+                else {
+                    result.production_assets = null;
+                }
+                pushSectionError(errors, TOOL_NAME, "production_assets", error, id);
+            }
+        }
+        // ADR-173 Decision 2 — every release this recording appears on,
+        // with its track position. Answers "which albums is this master
+        // on?" in one call.
+        if (allSections || sections?.includes("releases")) {
+            try {
+                result.releases = await this.pica.recordings.listReleases(id);
+            }
+            catch (error) {
+                if (!useStructured) {
+                    result.releases = [];
+                    result.releases_error =
+                        error instanceof Error ? error.message : "Failed to fetch releases";
+                }
+                else {
+                    result.releases = null;
+                }
+                pushSectionError(errors, TOOL_NAME, "releases", error, id);
+            }
+        }
+        const enriched = useStructured ? { ...result, errors } : result;
+        return formatSuccess("Recording details", enriched);
+    }
+    /**
+     * Create recording.
+     *
+     * `version_type` defaults to 'master' (the DB-level default and the
+     * canonical ADR-166 value). Pre-ADR-174 the executor defaulted to
+     * 'original', which is not a valid version_type — every call without
+     * an explicit type tripped the recording-type CHECK constraint and
+     * surfaced as a 500 from the service.
+     */
+    async createRecording(args) {
+        if (!args.version_type)
+            args.version_type = "master";
+        const recording = await this.pica.recordings.create(args);
+        // ADR-213 Primitive A — append attribution hints so every new recording
+        // prompts the ownership / credits / master-claim conversation by default.
+        // Mirror of buildCustodyHints (works.ts:723) for the recordings side.
+        const hints = buildRecordingAttributionHints(recording);
+        return formatSuccess("Recording created successfully", recording, hints);
+    }
+    /**
+     * Update recording
+     */
+    async updateRecording(args) {
+        const { id, ...updates } = args;
+        const recording = await this.pica.recordings.update(id, updates);
+        return formatSuccess("Recording updated successfully", recording);
+    }
+    /**
+     * Delete recording
+     */
+    async deleteRecording(args) {
+        await this.pica.recordings.delete(args.id);
+        return formatSuccess(`Recording ${args.id} deleted successfully`);
+    }
+}
+export { RECORDING_WRITE_PROPERTIES };
+//# sourceMappingURL=recordings.js.map