orbitmap 0.3.0 → 0.4.1

package/dist/adapters/local/adapter.d.ts

@@ -0,0 +1,351 @@
+/**
+ * LocalAdapter — the file-backed implementation of {@link WorkspaceAdapter} (spec §2.2).
+ *
+ * It never touches the network. Every method either
+ * - delegates to an entity module in `./entities/*` (tasks, work items, planning, docs),
+ * - is answered here from the store + `./shapes.js` (context, areas, overview, prompts), or
+ * - throws `NOT_SUPPORTED_IN_LOCAL_MODE` for the cloud-only surfaces of §1 (orbits,
+ *   document patching/sharing/visibility, presigned uploads).
+ *
+ * Commands never branch on the mode: everything mode-specific lives behind this class.
+ */
+import type { AreaSource } from '../../workspace-resolve.js';
+import type { WorkspaceAdapter } from '../types.js';
+import { LocalStore, type LocalStoreOptions } from './store.js';
+export interface LocalAdapterOptions {
+    workspacePath: string;
+    area?: string;
+    /** Rung that produced `area`; `'config'` marks it as the weak machine-wide default. */
+    areaSource?: AreaSource;
+    storeOptions?: LocalStoreOptions;
+    store?: LocalStore;
+}
+export declare class LocalAdapter implements WorkspaceAdapter {
+    private readonly options;
+    private context?;
+    constructor(options: LocalAdapterOptions);
+    /** Build (and memoise) the shared context: store + `workspace.yml` + resolved area. */
+    private ctx;
+    getContext(areaId?: string): Promise<unknown>;
+    /**
+     * The resolved area slug (§3.3, including the "workspace has exactly one area"
+     * auto-selection). Reads `workspace.yml` only — no credentials involved.
+     */
+    getDefaultArea(): Promise<string | undefined>;
+    getTasks(options?: {
+        status?: string;
+        priority?: string;
+        areaId?: string;
+        orbit?: string;
+    }): Promise<unknown>;
+    getTask(taskId: string): Promise<unknown>;
+    getTaskByNumber(taskNumber: string): Promise<unknown>;
+    startTask(taskId?: string): Promise<unknown>;
+    updateTaskStatus(taskId: string, status?: string, deliveryStatus?: string | null, force?: boolean): Promise<unknown>;
+    createSubtasks(parentId: string, subtasks: Array<{
+        title: string;
+        description?: string;
+        priority?: string;
+        estimated_effort?: string;
+    }>): Promise<unknown>;
+    createTask(data: {
+        title: string;
+        description?: string;
+        status?: string;
+        priority?: string;
+        agent_instructions?: string;
+        branch_name?: string;
+        estimated_effort?: string;
+        agent_id?: string;
+        area_id?: string;
+        source_issue_id?: string;
+        intent_id?: string;
+        orbit_id?: string | null;
+    }): Promise<unknown>;
+    editTaskContent(taskId: string, data: {
+        title?: string;
+        description?: string;
+        agent_instructions?: string;
+    }): Promise<unknown>;
+    assignTask(taskId: string, assignment: {
+        agent_id: string;
+    } | {
+        user_id: number;
+    }): Promise<unknown>;
+    assignItem(objectType: 'task' | 'issue' | 'idea' | 'intent', objectId: string, assignment: {
+        agent_id: string;
+    } | {
+        user_id: number;
+    }): Promise<unknown>;
+    addTaskDependency(taskId: string, data: {
+        target_task_id: string;
+        type?: string;
+        note?: string;
+    }): Promise<unknown>;
+    removeTaskDependency(taskId: string, targetTaskId: string, type?: string): Promise<unknown>;
+    logWork(taskId: string, type: string, content: string, metadata?: Record<string, unknown>): Promise<unknown>;
+    getDocuments(options?: {
+        type?: string;
+        search?: string;
+        areaId?: string;
+    }): Promise<unknown>;
+    getDocument(idOrSlug: string, mode?: 'inline' | 'file', options?: {
+        full?: boolean;
+        section?: string;
+    }): Promise<unknown>;
+    importDocument(data: {
+        title: string;
+        type: string;
+        content: string;
+        source_path?: string;
+        context?: string;
+        workspace_id?: string;
+    }): Promise<unknown>;
+    updateDocument(idOrSlug: string, content: string, changelog?: string): Promise<unknown>;
+    patchDocument(_idOrSlug: string, _operations: Array<Record<string, unknown>>, _baseVersion: number, _changelog?: string): Promise<unknown>;
+    requestUploadUrl(_data: {
+        title: string;
+        type: string;
+        filename?: string;
+        source_path?: string;
+        context?: string;
+        workspace_id?: string;
+    }): Promise<{
+        data: {
+            upload_id: string;
+            document_id: string;
+            presigned_url: string;
+            storage_path: string;
+            expires_at: string;
+        };
+    }>;
+    confirmUpload(_uploadId: string): Promise<{
+        data: {
+            document_id: string;
+            slug: string;
+            imported: boolean;
+        };
+    }>;
+    requestUpdateUploadUrl(_idOrSlug: string, _changelog?: string): Promise<{
+        data: {
+            upload_id: string;
+            document_id: string;
+            version: number;
+            presigned_url: string;
+            storage_path: string;
+            expires_at: string;
+        };
+    }>;
+    confirmUpdateUpload(_idOrSlug: string, _uploadId: string): Promise<{
+        data: {
+            document_id: string;
+            version: number;
+            updated: boolean;
+        };
+    }>;
+    uploadToPresignedUrl(_presignedUrl: string, _filePath: string, _onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<void>;
+    /**
+     * Presigned upload *negotiation* — never a user-facing surface: `doc-import` calls this
+     * first and falls back to `importDocument` when it returns `null` (exactly what
+     * `CloudAdapter` returns when the server declines the endpoint with 404). Local mode has
+     * no object storage, so it always declines instead of throwing.
+     */
+    presignedImport(_filePath: string, _data: {
+        title: string;
+        type: string;
+        source_path?: string;
+        context?: string;
+        workspace_id?: string;
+    }, _onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<{
+        data: {
+            document_id: string;
+            slug: string;
+            imported: boolean;
+        };
+        upload_method: string;
+    } | null>;
+    /** Same negotiation contract as {@link presignedImport}; `doc-update` falls back. */
+    presignedUpdate(_idOrSlug: string, _filePath: string, _changelog?: string, _onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<{
+        data: {
+            document_id: string;
+            version: number;
+            updated: boolean;
+        };
+        upload_method: string;
+    } | null>;
+    shareDocument(_documentId: string, _areaId: string, _agentIds?: string[]): Promise<unknown>;
+    unshareDocument(_documentId: string, _areaId: string): Promise<unknown>;
+    setDocumentVisibility(_documentId: string, _areaId: string, _agentIds: string[]): Promise<unknown>;
+    getAreas(): Promise<unknown>;
+    getAreaMembers(areaId: string): Promise<unknown>;
+    getAreaOverview(areaId: string): Promise<unknown>;
+    createArea(data: {
+        name: string;
+        description?: string;
+        slug?: string;
+        workspace_id?: string;
+    }): Promise<unknown>;
+    registerIssue(data: {
+        title: string;
+        description: string;
+        severity?: string;
+        related_task_id?: string;
+        intent_id?: string;
+    }): Promise<unknown>;
+    listIssues(options?: {
+        status?: string;
+        severity?: string;
+        limit?: string;
+    }): Promise<unknown>;
+    getIssue(idOrNumber: string): Promise<unknown>;
+    getIssueByNumber(issueNumber: string): Promise<unknown>;
+    resolveIssueByNumber(issueNumber: string, data: {
+        status: string;
+        resolution?: string;
+        resolved_by_task_id?: string;
+    }): Promise<unknown>;
+    resolveIssue(idOrNumber: string, data: {
+        status: string;
+        resolution?: string;
+        resolved_by_task_id?: string;
+    }): Promise<unknown>;
+    updateIssueStatus(idOrNumber: string, data: {
+        status: string;
+        resolution?: string;
+        resolved_task_id?: string;
+    }): Promise<unknown>;
+    updateIssueStatusByNumber(issueNumber: string, data: {
+        status: string;
+        resolution?: string;
+        resolved_task_id?: string;
+    }): Promise<unknown>;
+    logVibe(data: {
+        content: string;
+        type: string;
+        title?: string;
+        task_id?: string;
+    }): Promise<unknown>;
+    listVibes(options?: {
+        type?: string;
+        since?: string;
+        limit?: string;
+    }): Promise<unknown>;
+    getVibe(id: string): Promise<unknown>;
+    updateVibe(id: string, data: {
+        type?: string;
+        title?: string;
+        content?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    listIdeas(options?: {
+        status?: string;
+        priority?: string;
+        limit?: string;
+    }): Promise<unknown>;
+    getIdea(idOrNumber: string): Promise<unknown>;
+    getIdeaByNumber(ideaNumber: string): Promise<unknown>;
+    createIdea(data: {
+        content: string;
+        title?: string;
+        priority?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    updateIdeaStatus(idOrNumber: string, data: {
+        status: string;
+    }): Promise<unknown>;
+    updateIdeaStatusByNumber(ideaNumber: string, data: {
+        status: string;
+    }): Promise<unknown>;
+    listOrbits(_options?: {
+        areaId?: string;
+        workspaceId?: string;
+    }): Promise<unknown>;
+    getOrbit(_idOrSlug: string): Promise<unknown>;
+    createOrbit(_data: {
+        name: string;
+        description?: string;
+        color?: string;
+        area_ids?: string[];
+    }): Promise<unknown>;
+    updateOrbit(_idOrSlug: string, _data: {
+        name?: string;
+        description?: string;
+        status?: string;
+        color?: string;
+    }): Promise<unknown>;
+    getOrbitItems(_orbitIdOrSlug: string, _options?: {
+        type?: string;
+    }): Promise<unknown>;
+    orbitAttach(_orbitIdOrSlug: string, _data: {
+        object_type: string;
+        object_id: string;
+        note?: string;
+    }): Promise<unknown>;
+    orbitDetach(_orbitIdOrSlug: string, _data: {
+        object_type: string;
+        object_id: string;
+    }): Promise<unknown>;
+    addOrbitArea(_orbitIdOrSlug: string, _areaId: string): Promise<unknown>;
+    removeOrbitArea(_orbitIdOrSlug: string, _areaId: string): Promise<unknown>;
+    addOrbitDependency(_orbitIdOrSlug: string, _data: {
+        target_orbit_id: string;
+        note?: string;
+    }): Promise<unknown>;
+    listIntents(options?: {
+        status?: string;
+        limit?: string;
+    }): Promise<unknown>;
+    getIntent(idOrNumber: string): Promise<unknown>;
+    createIntent(data: {
+        name: string;
+        outcome?: string;
+        status?: string;
+        area_id?: string;
+    }): Promise<unknown>;
+    updateIntent(idOrNumber: string, data: {
+        name?: string;
+        outcome?: string;
+        status?: string;
+    }): Promise<unknown>;
+    linkIntentItem(idOrNumber: string, data: {
+        item_type: string;
+        item_id: string;
+    }): Promise<unknown>;
+    unlinkIntentItem(idOrNumber: string, data: {
+        item_type: string;
+        item_id: string;
+    }): Promise<unknown>;
+    setIntentOrbit(_idOrNumber: string, _orbitId: string | null): Promise<unknown>;
+    listMissions(options?: {
+        status?: string;
+        limit?: string;
+    }): Promise<unknown>;
+    getMission(idOrNumber: string): Promise<unknown>;
+    createMission(data: {
+        name: string;
+        description?: string;
+        outcome?: string;
+        end_date?: string;
+        area_id?: string;
+    }): Promise<unknown>;
+    updateMission(idOrNumber: string, data: {
+        name?: string;
+        description?: string;
+        outcome?: string;
+        end_date?: string;
+    }): Promise<unknown>;
+    setMissionStatus(idOrNumber: string, data: {
+        status: string;
+        move_target_mission_id?: string;
+    }): Promise<unknown>;
+    linkMissionItem(idOrNumber: string, data: {
+        item_type: string;
+        item_id: string;
+    }): Promise<unknown>;
+    unlinkMissionItem(idOrNumber: string, data: {
+        item_type: string;
+        item_id: string;
+    }): Promise<unknown>;
+    getWorkPrompt(): Promise<unknown>;
+    getImportDocsPrompt(): Promise<unknown>;
+}

package/dist/adapters/local/adapter.js

@@ -0,0 +1,346 @@
+/**
+ * LocalAdapter — the file-backed implementation of {@link WorkspaceAdapter} (spec §2.2).
+ *
+ * It never touches the network. Every method either
+ * - delegates to an entity module in `./entities/*` (tasks, work items, planning, docs),
+ * - is answered here from the store + `./shapes.js` (context, areas, overview, prompts), or
+ * - throws `NOT_SUPPORTED_IN_LOCAL_MODE` for the cloud-only surfaces of §1 (orbits,
+ *   document patching/sharing/visibility, presigned uploads).
+ *
+ * Commands never branch on the mode: everything mode-specific lives behind this class.
+ */
+import { createLocalContext, notSupported, requireAreaFile, resolveAreaRef, } from './context.js';
+import * as documents from './entities/documents.js';
+import * as planning from './entities/planning.js';
+import * as tasks from './entities/tasks.js';
+import * as workItems from './entities/work-items.js';
+import { assertUniqueAreaSlug, selectNextTask } from './rules.js';
+import { areaCreateEnvelope, areaMembersEnvelope, areaOverviewEnvelope, areasListEnvelope, contextEnvelope, documentEntry, findActiveMission, importDocsPromptEnvelope, parseDescription, workPromptEnvelope, } from './shapes.js';
+import { slugify } from './store.js';
+/** Statuses `orbitmap context` reports as "active tasks". */
+const CONTEXT_TASK_STATUSES = ['todo', 'in_progress'];
+export class LocalAdapter {
+    options;
+    context;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Build (and memoise) the shared context: store + `workspace.yml` + resolved area. */
+    async ctx() {
+        if (!this.context) {
+            this.context = await createLocalContext({
+                workspacePath: this.options.workspacePath,
+                area: this.options.area,
+                areaSource: this.options.areaSource,
+                storeOptions: this.options.storeOptions,
+                store: this.options.store,
+            });
+        }
+        return this.context;
+    }
+    // ── Context ──
+    async getContext(areaId) {
+        const ctx = await this.ctx();
+        let area;
+        if (areaId || ctx.areaSlug) {
+            area = await resolveAreaRef(ctx, areaId);
+        }
+        let areaTasks = [];
+        if (area) {
+            const files = await ctx.store.listEntities('task', { area: area.slug });
+            areaTasks = files
+                .map((file) => file.frontmatter)
+                .filter((task) => CONTEXT_TASK_STATUSES.includes(task.status));
+        }
+        const missions = (await ctx.store.listEntities('mission')).map((file) => file.frontmatter);
+        const docs = (await ctx.store.listDocuments()).map((doc) => documentEntry(doc.frontmatter, doc.body));
+        return contextEnvelope({
+            workspace: ctx.workspace,
+            area,
+            activeMission: findActiveMission(missions),
+            tasks: areaTasks,
+            documents: docs,
+        });
+    }
+    /**
+     * The resolved area slug (§3.3, including the "workspace has exactly one area"
+     * auto-selection). Reads `workspace.yml` only — no credentials involved.
+     */
+    async getDefaultArea() {
+        return (await this.ctx()).areaSlug;
+    }
+    // ── Tasks ──
+    async getTasks(options) {
+        return tasks.listTasks(await this.ctx(), options ?? {});
+    }
+    async getTask(taskId) {
+        return tasks.getTask(await this.ctx(), taskId);
+    }
+    async getTaskByNumber(taskNumber) {
+        return tasks.getTaskByNumber(await this.ctx(), taskNumber);
+    }
+    async startTask(taskId) {
+        return tasks.startTask(await this.ctx(), taskId);
+    }
+    async updateTaskStatus(taskId, status, deliveryStatus, force) {
+        return tasks.updateTaskStatus(await this.ctx(), taskId, status, deliveryStatus, force);
+    }
+    async createSubtasks(parentId, subtasks) {
+        return tasks.createSubtasks(await this.ctx(), parentId, subtasks);
+    }
+    async createTask(data) {
+        return tasks.createTask(await this.ctx(), data);
+    }
+    async editTaskContent(taskId, data) {
+        return tasks.editTaskContent(await this.ctx(), taskId, data);
+    }
+    // ── Assignment ──
+    async assignTask(taskId, assignment) {
+        return tasks.assignTask(await this.ctx(), taskId, assignment);
+    }
+    async assignItem(objectType, objectId, assignment) {
+        return tasks.assignItem(await this.ctx(), objectType, objectId, assignment);
+    }
+    // ── Task Dependencies ──
+    async addTaskDependency(taskId, data) {
+        return tasks.addTaskDependency(await this.ctx(), taskId, data);
+    }
+    async removeTaskDependency(taskId, targetTaskId, type) {
+        return tasks.removeTaskDependency(await this.ctx(), taskId, targetTaskId, type);
+    }
+    // ── Logs ──
+    async logWork(taskId, type, content, metadata) {
+        return tasks.logWork(await this.ctx(), taskId, type, content, metadata);
+    }
+    // ── Documents ──
+    async getDocuments(options) {
+        return documents.getDocuments(await this.ctx(), options);
+    }
+    async getDocument(idOrSlug, mode, options) {
+        return documents.getDocument(await this.ctx(), idOrSlug, mode, options);
+    }
+    async importDocument(data) {
+        return documents.importDocument(await this.ctx(), data);
+    }
+    async updateDocument(idOrSlug, content, changelog) {
+        return documents.updateDocument(await this.ctx(), idOrSlug, content, changelog);
+    }
+    async patchDocument(_idOrSlug, _operations, _baseVersion, _changelog) {
+        throw notSupported('Section-level document patching (`doc-patch`)');
+    }
+    // ── Presigned URL upload ──
+    async requestUploadUrl(_data) {
+        throw notSupported('Presigned document uploads');
+    }
+    async confirmUpload(_uploadId) {
+        throw notSupported('Presigned document uploads');
+    }
+    async requestUpdateUploadUrl(_idOrSlug, _changelog) {
+        throw notSupported('Presigned document uploads');
+    }
+    async confirmUpdateUpload(_idOrSlug, _uploadId) {
+        throw notSupported('Presigned document uploads');
+    }
+    async uploadToPresignedUrl(_presignedUrl, _filePath, _onProgress) {
+        throw notSupported('Presigned document uploads');
+    }
+    /**
+     * Presigned upload *negotiation* — never a user-facing surface: `doc-import` calls this
+     * first and falls back to `importDocument` when it returns `null` (exactly what
+     * `CloudAdapter` returns when the server declines the endpoint with 404). Local mode has
+     * no object storage, so it always declines instead of throwing.
+     */
+    async presignedImport(_filePath, _data, _onProgress) {
+        return null;
+    }
+    /** Same negotiation contract as {@link presignedImport}; `doc-update` falls back. */
+    async presignedUpdate(_idOrSlug, _filePath, _changelog, _onProgress) {
+        return null;
+    }
+    // ── Document sharing ──
+    async shareDocument(_documentId, _areaId, _agentIds) {
+        throw notSupported('Cross-area document sharing (`doc-share`)');
+    }
+    async unshareDocument(_documentId, _areaId) {
+        throw notSupported('Cross-area document sharing (`doc-unshare`)');
+    }
+    async setDocumentVisibility(_documentId, _areaId, _agentIds) {
+        throw notSupported('Document visibility (`doc-visibility`)');
+    }
+    // ── Areas ──
+    async getAreas() {
+        const ctx = await this.ctx();
+        const areas = await ctx.store.listAreas();
+        return areasListEnvelope(areas, ctx.workspace, ctx.areaSlug);
+    }
+    async getAreaMembers(areaId) {
+        const ctx = await this.ctx();
+        await resolveAreaRef(ctx, areaId);
+        return areaMembersEnvelope();
+    }
+    async getAreaOverview(areaId) {
+        const ctx = await this.ctx();
+        const area = await resolveAreaRef(ctx, areaId);
+        const files = await ctx.store.listEntities('task', { area: area.slug });
+        return areaOverviewEnvelope(area, files.map((file) => file.frontmatter));
+    }
+    async createArea(data) {
+        const ctx = await this.ctx();
+        const slug = data.slug ? slugify(data.slug) : slugify(data.name);
+        const existing = await ctx.store.listAreas();
+        assertUniqueAreaSlug(slug, existing.map((area) => area.slug));
+        const area = await ctx.store.scaffoldArea({
+            name: data.name,
+            slug,
+            description: data.description,
+        });
+        return areaCreateEnvelope(area, ctx.workspace);
+    }
+    // ── Issues ──
+    async registerIssue(data) {
+        return workItems.registerIssue(await this.ctx(), data);
+    }
+    async listIssues(options) {
+        return workItems.listIssues(await this.ctx(), options);
+    }
+    async getIssue(idOrNumber) {
+        return workItems.getIssue(await this.ctx(), idOrNumber);
+    }
+    async getIssueByNumber(issueNumber) {
+        return workItems.getIssueByNumber(await this.ctx(), issueNumber);
+    }
+    async resolveIssueByNumber(issueNumber, data) {
+        return workItems.resolveIssueByNumber(await this.ctx(), issueNumber, data);
+    }
+    async resolveIssue(idOrNumber, data) {
+        return workItems.resolveIssue(await this.ctx(), idOrNumber, data);
+    }
+    async updateIssueStatus(idOrNumber, data) {
+        return workItems.updateIssueStatus(await this.ctx(), idOrNumber, data);
+    }
+    async updateIssueStatusByNumber(issueNumber, data) {
+        return workItems.updateIssueStatusByNumber(await this.ctx(), issueNumber, data);
+    }
+    // ── Vibes ──
+    async logVibe(data) {
+        return workItems.logVibe(await this.ctx(), data);
+    }
+    async listVibes(options) {
+        return workItems.listVibes(await this.ctx(), options);
+    }
+    async getVibe(id) {
+        return workItems.getVibe(await this.ctx(), id);
+    }
+    async updateVibe(id, data) {
+        return workItems.updateVibe(await this.ctx(), id, data);
+    }
+    // ── Ideas ──
+    async listIdeas(options) {
+        return workItems.listIdeas(await this.ctx(), options);
+    }
+    async getIdea(idOrNumber) {
+        return workItems.getIdea(await this.ctx(), idOrNumber);
+    }
+    async getIdeaByNumber(ideaNumber) {
+        return workItems.getIdeaByNumber(await this.ctx(), ideaNumber);
+    }
+    async createIdea(data) {
+        return workItems.createIdea(await this.ctx(), data);
+    }
+    async updateIdeaStatus(idOrNumber, data) {
+        return workItems.updateIdeaStatus(await this.ctx(), idOrNumber, data);
+    }
+    async updateIdeaStatusByNumber(ideaNumber, data) {
+        return workItems.updateIdeaStatusByNumber(await this.ctx(), ideaNumber, data);
+    }
+    // ── Orbits (out of scope for the PoC — spec §1) ──
+    async listOrbits(_options) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async getOrbit(_idOrSlug) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async createOrbit(_data) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async updateOrbit(_idOrSlug, _data) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async getOrbitItems(_orbitIdOrSlug, _options) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async orbitAttach(_orbitIdOrSlug, _data) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async orbitDetach(_orbitIdOrSlug, _data) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async addOrbitArea(_orbitIdOrSlug, _areaId) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async removeOrbitArea(_orbitIdOrSlug, _areaId) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    async addOrbitDependency(_orbitIdOrSlug, _data) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    // ── Intents ──
+    async listIntents(options) {
+        return planning.listIntents(await this.ctx(), options);
+    }
+    async getIntent(idOrNumber) {
+        return planning.getIntent(await this.ctx(), idOrNumber);
+    }
+    async createIntent(data) {
+        return planning.createIntent(await this.ctx(), data);
+    }
+    async updateIntent(idOrNumber, data) {
+        return planning.updateIntent(await this.ctx(), idOrNumber, data);
+    }
+    async linkIntentItem(idOrNumber, data) {
+        return planning.linkIntentItem(await this.ctx(), idOrNumber, data);
+    }
+    async unlinkIntentItem(idOrNumber, data) {
+        return planning.unlinkIntentItem(await this.ctx(), idOrNumber, data);
+    }
+    async setIntentOrbit(_idOrNumber, _orbitId) {
+        throw notSupported('Orbits (`orbit` commands)');
+    }
+    // ── Missions ──
+    async listMissions(options) {
+        return planning.listMissions(await this.ctx(), options);
+    }
+    async getMission(idOrNumber) {
+        return planning.getMission(await this.ctx(), idOrNumber);
+    }
+    async createMission(data) {
+        return planning.createMission(await this.ctx(), data);
+    }
+    async updateMission(idOrNumber, data) {
+        return planning.updateMission(await this.ctx(), idOrNumber, data);
+    }
+    async setMissionStatus(idOrNumber, data) {
+        return planning.setMissionStatus(await this.ctx(), idOrNumber, data);
+    }
+    async linkMissionItem(idOrNumber, data) {
+        return planning.linkMissionItem(await this.ctx(), idOrNumber, data);
+    }
+    async unlinkMissionItem(idOrNumber, data) {
+        return planning.unlinkMissionItem(await this.ctx(), idOrNumber, data);
+    }
+    // ── Prompts ──
+    async getWorkPrompt() {
+        const ctx = await this.ctx();
+        const area = await requireAreaFile(ctx);
+        const files = await ctx.store.listEntities('task', { area: area.slug });
+        const picked = selectNextTask(files.map((file) => file.frontmatter));
+        if (!picked)
+            return workPromptEnvelope(area, null, null);
+        const file = files.find((entry) => entry.frontmatter.task_number === picked.task_number);
+        return workPromptEnvelope(area, file ? file.frontmatter : null, file ? parseDescription(file.body) : null);
+    }
+    async getImportDocsPrompt() {
+        return importDocsPromptEnvelope(await requireAreaFile(await this.ctx()));
+    }
+}
+//# sourceMappingURL=adapter.js.map