orbitmap 0.3.0 → 0.4.1

package/dist/adapters/local/entities/planning.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Local-mode missions and intents (spec §4.9–§4.10, task T8).
+ *
+ * Conventions every function follows:
+ * - first parameter is the shared {@link LocalContext} (store, workspace, area slug);
+ * - the remaining parameters are exactly the `WorkspaceAdapter` method parameters;
+ * - the return value is the raw Agent API envelope (`{ data: … }`, plus `meta` where the
+ *   fixtures have one), built with the local builders at the bottom of this file;
+ * - the single-active-mission rule (`assertSingleActiveMission`) and the
+ *   intent-exclusive-mission rule (`assertIntentExclusiveMission` / `applyIntentLink` /
+ *   `applyMissionLink`) come from `../rules.js` — never re-implemented here.
+ *
+ * `setIntentOrbit` is intentionally absent: orbits are out of scope for the PoC and the
+ * adapter answers that method with `NOT_SUPPORTED_IN_LOCAL_MODE`.
+ */
+import { type LocalContext } from '../context.js';
+import type { FoundEntity } from '../types.js';
+type MissionFile = FoundEntity<'mission'>;
+type IntentFile = FoundEntity<'intent'>;
+/** `GET /intents` — workspace-scoped, with status/limit filters. */
+export declare function listIntents(ctx: LocalContext, options?: {
+    status?: string;
+    limit?: string;
+}): Promise<unknown>;
+/** `GET /intents/{id}` — accepts a uuid, `IN-000001` or the bare code. */
+export declare function getIntent(ctx: LocalContext, idOrNumber: string): Promise<unknown>;
+/** `POST /intents`. */
+export declare function createIntent(ctx: LocalContext, data: {
+    name: string;
+    outcome?: string;
+    status?: string;
+    area_id?: string;
+}): Promise<unknown>;
+/** `PATCH /intents/{id}` — name, outcome (the body) and the status ladder. */
+export declare function updateIntent(ctx: LocalContext, idOrNumber: string, data: {
+    name?: string;
+    outcome?: string;
+    status?: string;
+}): Promise<unknown>;
+/**
+ * `POST /intents/{id}/items` — attach a task or issue to the intent.
+ * Rule 4: linking to an intent clears the item's direct mission (spec §6.4).
+ */
+export declare function linkIntentItem(ctx: LocalContext, idOrNumber: string, data: {
+    item_type: string;
+    item_id: string;
+}): Promise<unknown>;
+/** `DELETE /intents/{id}/items` — detach a task or issue from the intent. */
+export declare function unlinkIntentItem(ctx: LocalContext, idOrNumber: string, data: {
+    item_type: string;
+    item_id: string;
+}): Promise<unknown>;
+/** `GET /missions` — workspace-scoped, with status/limit filters. */
+export declare function listMissions(ctx: LocalContext, options?: {
+    status?: string;
+    limit?: string;
+}): Promise<unknown>;
+/**
+ * `GET /missions/{id}` — the mission plus its aggregated membership: every intent,
+ * task, issue and idea that points at it directly, plus the tasks/issues that belong
+ * to it transitively through one of its intents (spec §6.4).
+ */
+export declare function getMission(ctx: LocalContext, idOrNumber: string): Promise<unknown>;
+/** `POST /missions`. */
+export declare function createMission(ctx: LocalContext, data: {
+    name: string;
+    description?: string;
+    outcome?: string;
+    end_date?: string;
+    area_id?: string;
+}): Promise<unknown>;
+/** `PATCH /missions/{id}` — name, description (the body), outcome and end date. */
+export declare function updateMission(ctx: LocalContext, idOrNumber: string, data: {
+    name?: string;
+    description?: string;
+    outcome?: string;
+    end_date?: string;
+}): Promise<unknown>;
+/**
+ * `PATCH /missions/{id}/status` — enforces rule 5: activating a mission while another
+ * one is `active` fails and names the mission that must be completed or cancelled first.
+ *
+ * `move_target_mission_id` re-points every item directly linked to this mission at the
+ * given target mission (used when winding a mission down).
+ */
+export declare function setMissionStatus(ctx: LocalContext, idOrNumber: string, data: {
+    status: string;
+    move_target_mission_id?: string;
+}): Promise<unknown>;
+/**
+ * `POST /missions/{id}/items` — attach an intent, task, issue or idea to the mission.
+ * Rule 4: a task/issue that already has an intent cannot take a direct mission — the
+ * mission must be set on its intent instead (spec §6.4).
+ */
+export declare function linkMissionItem(ctx: LocalContext, idOrNumber: string, data: {
+    item_type: string;
+    item_id: string;
+}): Promise<unknown>;
+/** `DELETE /missions/{id}/items` — detach an item from the mission. */
+export declare function unlinkMissionItem(ctx: LocalContext, idOrNumber: string, data: {
+    item_type: string;
+    item_id: string;
+}): Promise<unknown>;
+/** Resolve `MS-000001`, the bare code `000001`, or the mission uuid. */
+export declare function requireMissionFile(ctx: LocalContext, ref: string): Promise<MissionFile>;
+/** Resolve `IN-000001`, the bare code `000001`, or the intent uuid. */
+export declare function requireIntentFile(ctx: LocalContext, ref: string): Promise<IntentFile>;
+export {};

package/dist/adapters/local/entities/planning.js

@@ -0,0 +1,540 @@
+/**
+ * Local-mode missions and intents (spec §4.9–§4.10, task T8).
+ *
+ * Conventions every function follows:
+ * - first parameter is the shared {@link LocalContext} (store, workspace, area slug);
+ * - the remaining parameters are exactly the `WorkspaceAdapter` method parameters;
+ * - the return value is the raw Agent API envelope (`{ data: … }`, plus `meta` where the
+ *   fixtures have one), built with the local builders at the bottom of this file;
+ * - the single-active-mission rule (`assertSingleActiveMission`) and the
+ *   intent-exclusive-mission rule (`assertIntentExclusiveMission` / `applyIntentLink` /
+ *   `applyMissionLink`) come from `../rules.js` — never re-implemented here.
+ *
+ * `setIntentOrbit` is intentionally absent: orbits are out of scope for the PoC and the
+ * adapter answers that method with `NOT_SUPPORTED_IN_LOCAL_MODE`.
+ */
+import { OrbitMapAPIError } from '../../../errors.js';
+import { LOCAL_AGENT_ID, LOCAL_AGENT_NAME, LOCAL_CREATED_BY, LOCAL_CREATED_BY_TYPE, LOCAL_USER_ID, newId, resolveAreaRef, } from '../context.js';
+import { applyIntentLink, applyMissionLink, assertEnum, assertIntentStatus, assertMissionStatus, assertSingleActiveMission, validationError, } from '../rules.js';
+import { stripEntityPrefix } from '../shapes.js';
+import { nowIso } from '../store.js';
+/** Item types `mission link|unlink` accepts. */
+const MISSION_ITEM_TYPES = ['intent', 'task', 'issue', 'idea'];
+/** Item types `intent link|unlink` accepts (spec §8.5: work items only). */
+const INTENT_ITEM_TYPES = ['task', 'issue'];
+// ── Intents (spec §4.10) ────────────────────────────────────────────────────
+/** `GET /intents` — workspace-scoped, with status/limit filters. */
+export async function listIntents(ctx, options) {
+    const files = await ctx.store.listEntities('intent');
+    const statuses = splitFilter(options?.status);
+    const items = files
+        .filter((file) => statuses.length === 0 || statuses.includes(file.frontmatter.status))
+        .sort(byNumber((file) => file.frontmatter.intent_number))
+        .map((file) => intentShape(ctx, file));
+    const limited = applyLimit(items, options?.limit);
+    return { data: limited, meta: { count: limited.length } };
+}
+/** `GET /intents/{id}` — accepts a uuid, `IN-000001` or the bare code. */
+export async function getIntent(ctx, idOrNumber) {
+    const file = await requireIntentFile(ctx, idOrNumber);
+    return { data: intentShape(ctx, file) };
+}
+/** `POST /intents`. */
+export async function createIntent(ctx, data) {
+    const name = (data.name ?? '').trim();
+    if (name.length === 0) {
+        throw validationError('Intent creation', 'name is required.');
+    }
+    const status = assertIntentStatus(data.status ?? 'new');
+    const areas = await resolveAreaSlugs(ctx, data.area_id);
+    const now = nowIso();
+    const created = await ctx.store.createEntity('intent', (intentNumber) => ({
+        frontmatter: {
+            id: newId(),
+            intent_number: intentNumber,
+            name,
+            status,
+            mission: null,
+            mission_position: null,
+            orbit: null,
+            roadmap_priority: 'parking lot',
+            areas,
+            assigned_agent: null,
+            assigned_user: null,
+            created_by: LOCAL_CREATED_BY,
+            created_at: now,
+            updated_at: now,
+        },
+        body: (data.outcome ?? '').trim(),
+    }));
+    return { data: intentShape(ctx, created) };
+}
+/** `PATCH /intents/{id}` — name, outcome (the body) and the status ladder. */
+export async function updateIntent(ctx, idOrNumber, data) {
+    const file = await requireIntentFile(ctx, idOrNumber);
+    let touched = false;
+    if (data.name !== undefined) {
+        const name = data.name.trim();
+        if (name.length === 0) {
+            throw validationError('Intent update', 'name must not be empty.');
+        }
+        file.frontmatter.name = name;
+        touched = true;
+    }
+    if (data.status !== undefined) {
+        file.frontmatter.status = assertIntentStatus(data.status);
+        touched = true;
+    }
+    if (data.outcome !== undefined) {
+        file.body = data.outcome.trim();
+        touched = true;
+    }
+    if (!touched) {
+        throw validationError('Intent update', 'at least one of name, outcome or status must be provided.');
+    }
+    file.frontmatter.updated_at = nowIso();
+    await ctx.store.writeEntity(file);
+    return { data: intentShape(ctx, file) };
+}
+/**
+ * `POST /intents/{id}/items` — attach a task or issue to the intent.
+ * Rule 4: linking to an intent clears the item's direct mission (spec §6.4).
+ */
+export async function linkIntentItem(ctx, idOrNumber, data) {
+    const file = await requireIntentFile(ctx, idOrNumber);
+    const itemType = assertEnum('item type', data.item_type, INTENT_ITEM_TYPES);
+    const item = await requireItem(ctx, itemType, data.item_id);
+    const record = linkable(item);
+    Object.assign(record, applyIntentLink(record, file.frontmatter.intent_number));
+    record.updated_at = nowIso();
+    await ctx.store.writeEntity(item);
+    return linkEnvelope('intent', file.frontmatter, itemType, item, true);
+}
+/** `DELETE /intents/{id}/items` — detach a task or issue from the intent. */
+export async function unlinkIntentItem(ctx, idOrNumber, data) {
+    const file = await requireIntentFile(ctx, idOrNumber);
+    const itemType = assertEnum('item type', data.item_type, INTENT_ITEM_TYPES);
+    const item = await requireItem(ctx, itemType, data.item_id);
+    const intentNumber = file.frontmatter.intent_number;
+    const record = linkable(item);
+    if ((record.intent ?? null) !== intentNumber) {
+        throw validationError('Intent link', `${itemNumberOf(item)} is not linked to intent ${intentNumber}.`, { intent: intentNumber, item: itemNumberOf(item) });
+    }
+    Object.assign(record, applyIntentLink(record, null));
+    record.updated_at = nowIso();
+    await ctx.store.writeEntity(item);
+    return linkEnvelope('intent', file.frontmatter, itemType, item, false);
+}
+// ── Missions (spec §4.9) ────────────────────────────────────────────────────
+/** `GET /missions` — workspace-scoped, with status/limit filters. */
+export async function listMissions(ctx, options) {
+    const files = await ctx.store.listEntities('mission');
+    const statuses = splitFilter(options?.status);
+    const items = files
+        .filter((file) => statuses.length === 0 || statuses.includes(file.frontmatter.status))
+        .sort(byNumber((file) => file.frontmatter.mission_number))
+        .map((file) => missionShape(ctx, file));
+    const limited = applyLimit(items, options?.limit);
+    return { data: limited, meta: { count: limited.length } };
+}
+/**
+ * `GET /missions/{id}` — the mission plus its aggregated membership: every intent,
+ * task, issue and idea that points at it directly, plus the tasks/issues that belong
+ * to it transitively through one of its intents (spec §6.4).
+ */
+export async function getMission(ctx, idOrNumber) {
+    const file = await requireMissionFile(ctx, idOrNumber);
+    const items = await collectMissionItems(ctx, file.frontmatter.mission_number);
+    return {
+        data: {
+            ...missionShape(ctx, file),
+            items,
+            items_count: items.intents.length +
+                items.tasks.length +
+                items.issues.length +
+                items.ideas.length,
+        },
+    };
+}
+/** `POST /missions`. */
+export async function createMission(ctx, data) {
+    const name = (data.name ?? '').trim();
+    if (name.length === 0) {
+        throw validationError('Mission creation', 'name is required.');
+    }
+    const existing = await ctx.store.listEntities('mission');
+    const sortOrder = existing.reduce((max, file) => Math.max(max, Number(file.frontmatter.sort_order ?? 0)), 0) + 1;
+    const now = nowIso();
+    const created = await ctx.store.createEntity('mission', (missionNumber) => ({
+        frontmatter: {
+            id: newId(),
+            mission_number: missionNumber,
+            name,
+            status: 'new',
+            outcome: data.outcome?.trim() || null,
+            start_date: null,
+            end_date: data.end_date ?? null,
+            sort_order: sortOrder,
+            created_by: LOCAL_CREATED_BY,
+            created_at: now,
+            updated_at: now,
+        },
+        body: (data.description ?? '').trim(),
+    }));
+    return { data: missionShape(ctx, created, { metadata: null }) };
+}
+/** `PATCH /missions/{id}` — name, description (the body), outcome and end date. */
+export async function updateMission(ctx, idOrNumber, data) {
+    const file = await requireMissionFile(ctx, idOrNumber);
+    let touched = false;
+    if (data.name !== undefined) {
+        const name = data.name.trim();
+        if (name.length === 0) {
+            throw validationError('Mission update', 'name must not be empty.');
+        }
+        file.frontmatter.name = name;
+        touched = true;
+    }
+    if (data.outcome !== undefined) {
+        file.frontmatter.outcome = data.outcome.trim() || null;
+        touched = true;
+    }
+    if (data.end_date !== undefined) {
+        file.frontmatter.end_date = data.end_date || null;
+        touched = true;
+    }
+    if (data.description !== undefined) {
+        file.body = data.description.trim();
+        touched = true;
+    }
+    if (!touched) {
+        throw validationError('Mission update', 'at least one of name, description, outcome or end_date must be provided.');
+    }
+    file.frontmatter.updated_at = nowIso();
+    await ctx.store.writeEntity(file);
+    return { data: missionShape(ctx, file) };
+}
+/**
+ * `PATCH /missions/{id}/status` — enforces rule 5: activating a mission while another
+ * one is `active` fails and names the mission that must be completed or cancelled first.
+ *
+ * `move_target_mission_id` re-points every item directly linked to this mission at the
+ * given target mission (used when winding a mission down).
+ */
+export async function setMissionStatus(ctx, idOrNumber, data) {
+    const file = await requireMissionFile(ctx, idOrNumber);
+    const status = assertMissionStatus(data.status);
+    const missionNumber = file.frontmatter.mission_number;
+    const missions = (await ctx.store.listEntities('mission')).map((entry) => entry.frontmatter);
+    assertSingleActiveMission(missionNumber, status, missions);
+    let target;
+    if (data.move_target_mission_id) {
+        target = await requireMissionFile(ctx, data.move_target_mission_id);
+        if (target.frontmatter.mission_number === missionNumber) {
+            throw validationError('Mission item move', `cannot move the items of ${missionNumber} to itself.`);
+        }
+    }
+    file.frontmatter.status = status;
+    if (status === 'active' && !file.frontmatter.start_date) {
+        file.frontmatter.start_date = nowIso().slice(0, 10);
+    }
+    file.frontmatter.updated_at = nowIso();
+    await ctx.store.writeEntity(file);
+    if (target) {
+        await moveMissionItems(ctx, missionNumber, target.frontmatter.mission_number);
+    }
+    return { data: missionShape(ctx, file) };
+}
+/**
+ * `POST /missions/{id}/items` — attach an intent, task, issue or idea to the mission.
+ * Rule 4: a task/issue that already has an intent cannot take a direct mission — the
+ * mission must be set on its intent instead (spec §6.4).
+ */
+export async function linkMissionItem(ctx, idOrNumber, data) {
+    const file = await requireMissionFile(ctx, idOrNumber);
+    const itemType = assertEnum('item type', data.item_type, MISSION_ITEM_TYPES);
+    const item = await requireItem(ctx, itemType, data.item_id);
+    const missionNumber = file.frontmatter.mission_number;
+    const record = linkable(item);
+    if (itemType === 'intent') {
+        record.mission = missionNumber;
+    }
+    else {
+        Object.assign(record, applyMissionLink(record, missionNumber));
+    }
+    record.updated_at = nowIso();
+    await ctx.store.writeEntity(item);
+    return linkEnvelope('mission', file.frontmatter, itemType, item, true);
+}
+/** `DELETE /missions/{id}/items` — detach an item from the mission. */
+export async function unlinkMissionItem(ctx, idOrNumber, data) {
+    const file = await requireMissionFile(ctx, idOrNumber);
+    const itemType = assertEnum('item type', data.item_type, MISSION_ITEM_TYPES);
+    const item = await requireItem(ctx, itemType, data.item_id);
+    const missionNumber = file.frontmatter.mission_number;
+    const record = linkable(item);
+    if ((record.mission ?? null) !== missionNumber) {
+        throw validationError('Mission link', `${itemNumberOf(item)} is not linked directly to mission ${missionNumber}.`, { mission: missionNumber, item: itemNumberOf(item) });
+    }
+    record.mission = null;
+    record.mission_position = null;
+    record.updated_at = nowIso();
+    await ctx.store.writeEntity(item);
+    return linkEnvelope('mission', file.frontmatter, itemType, item, false);
+}
+// ── Lookups ─────────────────────────────────────────────────────────────────
+/** Resolve `MS-000001`, the bare code `000001`, or the mission uuid. */
+export async function requireMissionFile(ctx, ref) {
+    return requirePlanningFile(ctx, 'mission', ref, 'MS', 'Mission');
+}
+/** Resolve `IN-000001`, the bare code `000001`, or the intent uuid. */
+export async function requireIntentFile(ctx, ref) {
+    return requirePlanningFile(ctx, 'intent', ref, 'IN', 'Intent');
+}
+async function requirePlanningFile(ctx, kind, ref, prefix, label) {
+    const trimmed = (ref ?? '').trim();
+    const numbers = [];
+    if (/^[A-Za-z]{2}-/.test(trimmed)) {
+        numbers.push(`${trimmed.slice(0, 2).toUpperCase()}${trimmed.slice(2)}`);
+    }
+    else if (/^[0-9a-zA-Z]+$/.test(trimmed)) {
+        numbers.push(`${prefix}-${trimmed}`);
+    }
+    for (const number of numbers) {
+        const found = await ctx.store.tryReadEntity(kind, number);
+        if (found)
+            return found;
+    }
+    const all = await ctx.store.listEntities(kind);
+    const byId = all.find((file) => file.frontmatter.id === trimmed);
+    if (byId)
+        return byId;
+    throw new OrbitMapAPIError(`${label} \`${ref}\` was not found in this workspace.`, 'NOT_FOUND', 404);
+}
+/** Resolve a linkable item and assert it really is of the requested kind. */
+async function requireItem(ctx, itemType, itemId) {
+    const trimmed = (itemId ?? '').trim();
+    if (trimmed.length === 0) {
+        throw validationError('Item link', 'item_id is required.');
+    }
+    const found = await ctx.store.findEntity(trimmed);
+    if (!found) {
+        throw new OrbitMapAPIError(`\`${itemId}\` was not found in this workspace.`, 'NOT_FOUND', 404);
+    }
+    if (found.kind !== itemType) {
+        throw validationError('Item link', `${itemNumberOf(found)} is a ${found.kind}, not a ${itemType}.`);
+    }
+    return found;
+}
+/**
+ * Walk the workspace files and collect everything that belongs to `missionNumber`:
+ * items whose frontmatter `mission` points at it (`linked_via: 'direct'`), plus the
+ * tasks/issues whose `intent` points at one of the mission's intents (`linked_via` =
+ * that intent's number).
+ */
+async function collectMissionItems(ctx, missionNumber) {
+    const intentFiles = await ctx.store.listEntities('intent');
+    const memberIntents = intentFiles
+        .map((file) => file.frontmatter)
+        .filter((intent) => intent.mission === missionNumber)
+        .sort((a, b) => a.intent_number.localeCompare(b.intent_number));
+    const memberIntentNumbers = new Set(memberIntents.map((intent) => intent.intent_number));
+    const via = (item) => {
+        if (item.intent && memberIntentNumbers.has(item.intent))
+            return item.intent;
+        if (!item.intent && item.mission === missionNumber)
+            return 'direct';
+        return null;
+    };
+    const tasks = [];
+    for (const file of await ctx.store.listEntities('task')) {
+        const task = file.frontmatter;
+        const link = via(task);
+        if (!link)
+            continue;
+        tasks.push({
+            type: 'task',
+            id: task.id,
+            display_number: task.task_number,
+            title: task.title,
+            status: task.status,
+            linked_via: link,
+        });
+    }
+    const issues = [];
+    for (const file of await ctx.store.listEntities('issue')) {
+        const issue = file.frontmatter;
+        const link = via(issue);
+        if (!link)
+            continue;
+        issues.push({
+            type: 'issue',
+            id: issue.id,
+            display_number: issue.issue_number,
+            title: issue.title,
+            status: issue.status,
+            linked_via: link,
+        });
+    }
+    const ideas = [];
+    for (const file of await ctx.store.listEntities('idea')) {
+        const idea = file.frontmatter;
+        if (idea.mission !== missionNumber)
+            continue;
+        ideas.push({
+            type: 'idea',
+            id: idea.id,
+            display_number: idea.idea_number,
+            title: idea.title,
+            status: idea.status,
+            linked_via: 'direct',
+        });
+    }
+    return {
+        intents: memberIntents.map((intent) => ({
+            type: 'intent',
+            id: intent.id,
+            display_number: intent.intent_number,
+            title: intent.name,
+            status: intent.status,
+            linked_via: 'direct',
+        })),
+        tasks: tasks.sort(byDisplayNumber),
+        issues: issues.sort(byDisplayNumber),
+        ideas: ideas.sort(byDisplayNumber),
+    };
+}
+/** Re-point every directly linked item of `from` at `to` (mission wind-down). */
+async function moveMissionItems(ctx, from, to) {
+    const kinds = ['intent', 'task', 'issue', 'idea'];
+    const timestamp = nowIso();
+    for (const kind of kinds) {
+        for (const file of await ctx.store.listEntities(kind)) {
+            const record = linkable(file);
+            if (record.mission !== from)
+                continue;
+            record.mission = to;
+            record.updated_at = timestamp;
+            await ctx.store.writeEntity(file);
+        }
+    }
+}
+// ── Envelope builders (mission/intent specific) ─────────────────────────────
+/** `created_by` block — always the implicit local agent (spec §2.2). */
+function createdByShape() {
+    return {
+        type: LOCAL_CREATED_BY_TYPE,
+        id: LOCAL_AGENT_ID,
+        name: LOCAL_AGENT_NAME,
+    };
+}
+/**
+ * Mission in the API's envelope shape (fixtures `mission-create`, `mission-show`,
+ * `missions-list`). `description` is the file body; `metadata` is a server-only
+ * concept and carries the fixtures' placeholder.
+ */
+function missionShape(ctx, file, options = {}) {
+    const mission = file.frontmatter;
+    return {
+        id: mission.id,
+        mission_number: stripEntityPrefix(mission.mission_number),
+        display_number: mission.mission_number,
+        name: mission.name,
+        description: file.body.length > 0 ? file.body : null,
+        outcome: mission.outcome ?? null,
+        status: mission.status,
+        workspace_id: ctx.workspace.workspace_id,
+        start_date: mission.start_date ?? null,
+        end_date: mission.end_date ?? null,
+        created_by: createdByShape(),
+        metadata: options.metadata === undefined ? [] : options.metadata,
+        created_at: mission.created_at,
+        updated_at: mission.updated_at,
+    };
+}
+/**
+ * Intent in the API's envelope shape (fixtures `intent-create`, `intent-show`,
+ * `intents-list`). `outcome` is the file body; relations are entity numbers.
+ */
+function intentShape(ctx, file) {
+    const intent = file.frontmatter;
+    return {
+        id: intent.id,
+        intent_number: stripEntityPrefix(intent.intent_number),
+        display_number: intent.intent_number,
+        name: intent.name,
+        outcome: file.body.length > 0 ? file.body : null,
+        status: intent.status,
+        workspace_id: ctx.workspace.workspace_id,
+        orbit_id: null,
+        mission_id: intent.mission ?? null,
+        assigned_user_id: intent.assigned_user ? LOCAL_USER_ID : null,
+        assigned_agent_id: intent.assigned_agent ?? null,
+        created_by: createdByShape(),
+        metadata: [],
+        created_at: intent.created_at,
+        updated_at: intent.updated_at,
+    };
+}
+/** `POST|DELETE /{missions|intents}/{id}/items` envelope. */
+function linkEnvelope(parentType, parent, itemType, item, linked) {
+    const parentNumber = parentType === 'mission'
+        ? parent.mission_number
+        : parent.intent_number;
+    return {
+        data: {
+            [`${parentType}_id`]: parent.id,
+            [`${parentType}_number`]: stripEntityPrefix(parentNumber),
+            display_number: parentNumber,
+            item_type: itemType,
+            item_id: String(item.frontmatter.id ?? ''),
+            item_number: itemNumberOf(item),
+            linked,
+            unlinked: !linked,
+        },
+    };
+}
+/** The located entity's frontmatter, viewed as a linkable record (same object). */
+function linkable(item) {
+    return item.frontmatter;
+}
+/** The entity number of any located entity (`TS-…`, `IS-…`, `ID-…`, `IN-…`, `MS-…`). */
+function itemNumberOf(item) {
+    const record = item.frontmatter;
+    const value = record.task_number ??
+        record.issue_number ??
+        record.idea_number ??
+        record.intent_number ??
+        record.mission_number ??
+        record.vibe_number;
+    return typeof value === 'string' ? value : String(record.id ?? '');
+}
+/** Area slugs for the `intent_area` pivot: the explicit area, else the context area. */
+async function resolveAreaSlugs(ctx, areaId) {
+    if (areaId)
+        return [(await resolveAreaRef(ctx, areaId)).slug];
+    return ctx.areaSlug ? [ctx.areaSlug] : [];
+}
+function splitFilter(value) {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+}
+function applyLimit(items, limit) {
+    if (!limit)
+        return items;
+    const parsed = Number.parseInt(limit, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return items;
+    return items.slice(0, parsed);
+}
+function byNumber(pick) {
+    return (a, b) => pick(a).localeCompare(pick(b));
+}
+function byDisplayNumber(a, b) {
+    return a.display_number.localeCompare(b.display_number);
+}
+//# sourceMappingURL=planning.js.map