@bpmsoftwaresolutions/ai-engine-client 1.1.74 → 1.1.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmsoftwaresolutions/ai-engine-client",
-  "version": "1.1.74",
+  "version": "1.1.75",
   "description": "Thin npm client for the AI Engine operator and retrieval APIs",
   "type": "module",
   "main": "./src/index.js",

package/src/client.js

@@ -18,8 +18,16 @@ import { createNotesLabDomain } from './domains/notes-lab.js';
 import { createProjectionsDomain } from './domains/projections.js';
 import { createReportsDomain } from './domains/reports.js';
 import { createPerformanceDomain } from './domains/performance.js';
+import { createImplementationArtifactsDomain } from './domains/implementation-artifacts.js';
+import { createImplementationEvidenceDomain } from './domains/implementation-evidence.js';
+import { createImplementationGatesDomain } from './domains/implementation-gates.js';
+import { createImplementationPacketsDomain } from './domains/implementation-packets.js';
+import { createImplementationItemsDomain } from './domains/implementation-items.js';
 import { createRepoDomain } from './domains/repo.js';
+import { createProjectCharteringDomain } from './domains/project-chartering.js';
+import { createProjectsDomain } from './domains/projects.js';
 import { createOperatorStatusDomain } from './domains/operator-status.js';
+import { createRoadmapsDomain } from './domains/roadmaps.js';
 import { createScriptDiscoveryDomain } from './domains/script-discovery.js';
 import { createScriptsDomain } from './domains/scripts.js';
 import { createRetrievalManagementDomain } from './domains/retrieval-management.js';
@@ -367,6 +375,14 @@ export class AIEngineClient {
       currentProject: createCurrentProjectDomain(this),
     };
     this.database = createDatabaseDomain(this);
+    this.projects = createProjectsDomain(this);
+    this.projectChartering = createProjectCharteringDomain(this);
+    this.roadmaps = createRoadmapsDomain(this);
+    this.implementationPackets = createImplementationPacketsDomain(this);
+    this.implementationItems = createImplementationItemsDomain(this);
+    this.implementationArtifacts = createImplementationArtifactsDomain(this);
+    this.implementationEvidence = createImplementationEvidenceDomain(this);
+    this.implementationGates = createImplementationGatesDomain(this);
     this.implementationTasks = createImplementationTasksDomain(this);
     this.skills = createSkillsDomain(this);
     this.skillGovernance = createSkillGovernanceDomain(this);
@@ -5725,39 +5741,23 @@ export class AIEngineClient {
   }
 
   async createProjectDelivery(body = {}) {
-    return this._request('/api/project-delivery', { method: 'POST', body });
+    return this.projectChartering.createProjectDelivery(body);
   }
 
   async approveProjectCharterIntent(projectId, body = {}) {
-    if (!projectId) throw new Error('projectId is required.');
-    return this._request(`/api/project-delivery/${encodeURIComponent(projectId)}/approve-charter-intent`, {
-      method: 'POST',
-      body,
-    });
+    return this.projectChartering.approveProjectCharterIntent(projectId, body);
   }
 
   async approveImplementationRoadmap(projectId, body = {}) {
-    if (!projectId) throw new Error('projectId is required.');
-    return this._request(`/api/project-delivery/${encodeURIComponent(projectId)}/approve-roadmap`, {
-      method: 'POST',
-      body,
-    });
+    return this.projectChartering.approveImplementationRoadmap(projectId, body);
   }
 
   async runProjectCharter(projectId, body = {}) {
-    if (!projectId) throw new Error('projectId is required.');
-    return this._request(`/api/project-delivery/${encodeURIComponent(projectId)}/run-charter`, {
-      method: 'POST',
-      body,
-    });
+    return this.projectChartering.runProjectCharter(projectId, body);
   }
 
   async beginImplementationRoadmap(projectId, body = {}) {
-    if (!projectId) throw new Error('projectId is required.');
-    return this._request(`/api/project-delivery/${encodeURIComponent(projectId)}/begin-roadmap`, {
-      method: 'POST',
-      body,
-    });
+    return this.projectChartering.beginImplementationRoadmap(projectId, body);
   }
 
   async routeImplementationItem(implementationItemId, body = {}) {
@@ -6184,49 +6184,37 @@ export class AIEngineClient {
     assignedTo,
     createAcceptanceSubtasks = true,
   } = {}) {
-    return this._request('/api/projects/charter', {
-      method: 'POST',
-      body: {
-        project_name: projectName,
-        objective,
-        business_context: businessContext,
-        success_criteria: successCriteria,
-        priority,
-        constraints,
-        in_scope: inScope,
-        out_of_scope: outOfScope,
-        assumptions,
-        linked_workflows: linkedWorkflows,
-        linked_workflow_slug: linkedWorkflowSlug,
-        testing_strategy: testingStrategy,
-        initial_context: initialContext,
-        requested_by: requestedBy,
-        ensure_task_surface: ensureTaskSurface,
-        assigned_to: assignedTo,
-        create_acceptance_subtasks: createAcceptanceSubtasks,
-      },
+    return this.projectChartering.createProjectCharter({
+      projectName,
+      objective,
+      businessContext,
+      successCriteria,
+      priority,
+      constraints,
+      inScope,
+      outOfScope,
+      assumptions,
+      linkedWorkflows,
+      linkedWorkflowSlug,
+      testingStrategy,
+      initialContext,
+      requestedBy,
+      ensureTaskSurface,
+      assignedTo,
+      createAcceptanceSubtasks,
     });
   }
 
   async listProjects({ limit, includeInactive, processStatus, charterStatus } = {}) {
-    return this._request('/api/operator/projects', {
-      query: {
-        limit,
-        include_inactive: includeInactive,
-        process_status: processStatus,
-        charter_status: charterStatus,
-      },
-    });
+    return this.projects.listProjects({ limit, includeInactive, processStatus, charterStatus });
   }
 
   async getProject(projectId) {
-    return this._request(`/api/operator/projects/${projectId}`);
+    return this.projects.getProject(projectId);
   }
 
   async listProjectWorkflowRuns(projectId, { limit = 25 } = {}) {
-    return this._request(`/api/operator/projects/${projectId}/workflow-runs`, {
-      query: { limit },
-    });
+    return this.projects.listProjectWorkflowRuns(projectId, { limit });
   }
 
   async closeProject(projectId, {
@@ -6297,26 +6285,23 @@ export class AIEngineClient {
   }
 
   async getProjectCharterReport(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/charter/report`);
+    return this.projects.getProjectCharterReport(projectId);
   }
 
   async createProjectMarkdownDownload(projectId, { reportType, includeMarkdown = false } = {}) {
-    return this._request(`/api/operator/projects/${projectId}/markdown-report-downloads`, {
-      method: 'POST',
-      body: { report_type: reportType, include_markdown: includeMarkdown },
-    });
+    return this.projects.createProjectMarkdownDownload(projectId, { reportType, includeMarkdown });
   }
 
   async downloadProjectMarkdownReport(projectId, reportType) {
-    return this._requestText(`/api/operator/projects/${projectId}/markdown-reports/${reportType}/download`);
+    return this.projects.downloadProjectMarkdownReport(projectId, reportType);
   }
 
   async downloadProjectCharterReportMarkdown(projectId) {
-    return this.downloadProjectMarkdownReport(projectId, 'charter');
+    return this.projects.downloadProjectCharterReportMarkdown(projectId);
   }
 
   async getProjectBundle(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/bundle`);
+    return this.projects.getProjectBundle(projectId);
   }
 
   async resumeProjectWork({
@@ -6327,17 +6312,13 @@ export class AIEngineClient {
     requireClaim,
     workflowRunLimit,
   } = {}) {
-    const normalizedProjectIdentifier = cleanText(projectIdentifier) || cleanText(projectId);
-    if (!normalizedProjectIdentifier) {
-      throw new Error('projectIdentifier is required.');
-    }
-    return this._request(`/api/operator/projects/${encodeURIComponent(normalizedProjectIdentifier)}/resume-context`, {
-      query: {
-        actor_mode: actorMode,
-        execution_intent: executionIntent,
-        require_claim: requireClaim,
-        workflow_run_limit: workflowRunLimit,
-      },
+    return this.projects.resumeProjectWork({
+      projectIdentifier,
+      projectId,
+      actorMode,
+      executionIntent,
+      requireClaim,
+      workflowRunLimit,
     });
   }
 
@@ -6835,29 +6816,27 @@ export class AIEngineClient {
   // ─── Roadmaps ──────────────────────────────────────────────────────────────
 
   async listProjectRoadmaps({ includeInactive } = {}) {
-    return this._request('/api/operator/projects/implementation-roadmaps', {
-      query: { include_inactive: includeInactive },
-    });
+    return this.roadmaps.listProjectRoadmaps({ includeInactive });
   }
 
   async getProjectRoadmap(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/implementation-roadmap`);
+    return this.roadmaps.getProjectRoadmap(projectId);
   }
 
   async getProjectRoadmapSummary(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/implementation-roadmap/summary`);
+    return this.roadmaps.getProjectRoadmapSummary(projectId);
   }
 
   async getProjectRoadmapActiveItem(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/implementation-roadmap/active-item`);
+    return this.roadmaps.getProjectRoadmapActiveItem(projectId);
   }
 
   async getProjectImplementationRoadmapReport(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/implementation-roadmap/report`);
+    return this.roadmaps.getProjectImplementationRoadmapReport(projectId);
   }
 
   async downloadProjectImplementationRoadmapReportMarkdown(projectId) {
-    return this.downloadProjectMarkdownReport(projectId, 'implementation_roadmap');
+    return this.roadmaps.downloadProjectImplementationRoadmapReportMarkdown(projectId);
   }
 
   async ensureProjectRoadmapTaskSurface(projectId, {
@@ -6865,13 +6844,10 @@ export class AIEngineClient {
     assignedTo,
     createAcceptanceSubtasks = true,
   } = {}) {
-    return this._request(`/api/operator/projects/${projectId}/implementation-roadmap/task-surface`, {
-      method: 'POST',
-      body: {
-        requested_by: requestedBy,
-        assigned_to: assignedTo,
-        create_acceptance_subtasks: createAcceptanceSubtasks,
-      },
+    return this.roadmaps.ensureProjectRoadmapTaskSurface(projectId, {
+      requestedBy,
+      assignedTo,
+      createAcceptanceSubtasks,
     });
   }
 
@@ -6976,13 +6952,11 @@ export class AIEngineClient {
   }
 
   async listProjectOpenTasks(projectId) {
-    return this._request(`/api/operator/projects/${projectId}/open-tasks`);
+    return this.projects.listProjectOpenTasks(projectId);
   }
 
   async getProjectPerformanceMetrics(projectId, { workflowId, workflowRunId, sinceUtc } = {}) {
-    return this._request(`/api/operator/projects/${projectId}/performance-metrics`, {
-      query: { workflow_id: workflowId, workflow_run_id: workflowRunId, since_utc: sinceUtc },
-    });
+    return this.projects.getProjectPerformanceMetrics(projectId, { workflowId, workflowRunId, sinceUtc });
   }
 
   _resolveImplementationPacketProjectReference(packetPayload) {
@@ -7057,127 +7031,76 @@ export class AIEngineClient {
     executionType,
     executionPurpose,
   } = {}) {
-    const normalizedClaimId = cleanText(claimId);
-    const normalizedClaimProjectId = cleanText(claimProjectId) || cleanText(projectId);
-    const normalizedClaimedItemId = cleanText(claimedItemId) || implementationItemId;
-    const normalizedWorkflowRunId = cleanText(workflowRunId);
-    const normalizedAgentSessionId = cleanText(agentSessionId);
-    const normalizedAllowedMutationSurfaces = Array.isArray(allowedMutationSurfaces) && allowedMutationSurfaces.length > 0
-      ? allowedMutationSurfaces
-      : ['project_roadmap_task'];
-    const normalizedAcknowledgedReminders = Array.isArray(acknowledgedReminders)
-      ? acknowledgedReminders
-      : undefined;
-    const normalizedExecutionIntent = (() => {
-      if (executionIntent && typeof executionIntent === 'object') {
-        const execution_type = cleanText(executionIntent.execution_type) || cleanText(executionIntent.executionType);
-        const execution_purpose = cleanText(executionIntent.execution_purpose) || cleanText(executionIntent.executionPurpose);
-        if (execution_type || execution_purpose) {
-          return {
-            ...(execution_type ? { execution_type } : {}),
-            ...(execution_purpose ? { execution_purpose } : {}),
-          };
-        }
-      }
-      const normalizedExecutionType = cleanText(executionType) || 'implementation_task';
-      const normalizedExecutionPurpose = cleanText(executionPurpose) || cleanText(title) || 'implementation task';
-      return {
-        execution_type: normalizedExecutionType,
-        execution_purpose: normalizedExecutionPurpose,
-      };
-    })();
-    await this._assertExecutionEligibility({
-      claim_id: normalizedClaimId,
-      claim_project_id: normalizedClaimProjectId,
-      claimed_item_id: normalizedClaimedItemId,
-      workflow_run_id: normalizedWorkflowRunId,
-      agent_session_id: normalizedAgentSessionId,
-      allowed_mutation_surfaces: normalizedAllowedMutationSurfaces,
-      acknowledged_reminders: normalizedAcknowledgedReminders || [],
-      requested_mutation_surface: 'project_roadmap_task',
-      verification_required: true,
-    });
-    return this._request(`/api/operator/implementation-items/${implementationItemId}/tasks`, {
-      method: 'POST',
-      body: {
-        title,
-        implementation_packet_id: implementationPacketId,
-        description,
-        priority,
-        assigned_to: assignedTo,
-        assigned_by: assignedBy,
-        due_at: dueAt,
-        sort_order: sortOrder,
-        notes,
-        created_by: createdBy,
-        parent_task_id: parentTaskId,
-        claim_id: normalizedClaimId,
-        claim_project_id: normalizedClaimProjectId,
-        claimed_item_id: normalizedClaimedItemId,
-        workflow_run_id: normalizedWorkflowRunId,
-        agent_session_id: normalizedAgentSessionId,
-        allowed_mutation_surfaces: normalizedAllowedMutationSurfaces,
-        acknowledged_reminders: normalizedAcknowledgedReminders,
-        execution_intent: normalizedExecutionIntent,
-      },
+    return this.implementationItems.createImplementationTask(implementationItemId, {
+      title,
+      implementationPacketId,
+      description,
+      priority,
+      assignedTo,
+      assignedBy,
+      dueAt,
+      sortOrder,
+      notes,
+      createdBy,
+      parentTaskId,
+      claimId,
+      claimProjectId,
+      projectId,
+      claimedItemId,
+      workflowRunId,
+      agentSessionId,
+      allowedMutationSurfaces,
+      acknowledgedReminders,
+      executionIntent,
+      executionType,
+      executionPurpose,
     });
   }
 
   async listImplementationTasks(implementationItemId) {
-    return this._request(`/api/operator/implementation-items/${implementationItemId}/tasks`);
+    return this.implementationItems.listImplementationTasks(implementationItemId);
   }
 
   async listImplementationSubtasks(taskId) {
-    return this._request(`/api/operator/implementation-item-tasks/${taskId}/subtasks`);
+    return this.implementationItems.listImplementationSubtasks(taskId);
   }
 
   async updateImplementationTask(taskId, updates) {
-    return this._request(`/api/operator/implementation-item-tasks/${taskId}`, {
-      method: 'PATCH',
-      body: updates,
-    });
+    return this.implementationItems.updateImplementationTask(taskId, updates);
   }
 
   async assignImplementationTask(taskId, { assignedTo, assignedBy } = {}) {
-    return this._request(`/api/operator/implementation-item-tasks/${taskId}/assign`, {
-      method: 'POST',
-      body: { assigned_to: assignedTo, assigned_by: assignedBy },
-    });
+    return this.implementationItems.assignImplementationTask(taskId, { assignedTo, assignedBy });
   }
 
   async completeImplementationTask(taskId, { completedBy } = {}) {
-    return this._request(`/api/operator/implementation-item-tasks/${taskId}/complete`, {
-      method: 'POST',
-      body: { completed_by: completedBy },
-    });
+    return this.implementationItems.completeImplementationTask(taskId, { completedBy });
   }
 
   // ─── Governed Implementation ───────────────────────────────────────────────
 
   async importImplementationPacket(body) {
-    return this._request('/api/governed-implementation/packets/import', { method: 'POST', body });
+    return this.implementationPackets.importImplementationPacket(body);
   }
 
   async listImplementationPackets({ status, packetType } = {}) {
-    return this._request('/api/governed-implementation/packets', {
-      query: { status, packet_type: packetType },
-    });
+    return this.implementationPackets.listImplementationPackets({ status, packetType });
   }
 
   async getImplementationPacket(packetId) {
-    return this._request(`/api/governed-implementation/packets/${packetId}`);
+    return this.implementationPackets.getImplementationPacket(packetId);
   }
 
   async getImplementationItemAcceptanceChecks(implementationItemId) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/acceptance-checks`);
+    return this.implementationGates.getImplementationItemAcceptanceChecks(implementationItemId);
   }
 
   async getArtifactManifest(implementationItemId) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/artifact-manifest`);
+    return this.implementationArtifacts.getArtifactManifest(implementationItemId);
   }
 
   async getDecisionPacket(implementationItemId) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/decision-packet`);
+    return this.implementationArtifacts.getDecisionPacket(implementationItemId);
   }
 
   async updateImplementationItemStatus(implementationItemId, body) {
@@ -7224,19 +7147,15 @@ export class AIEngineClient {
   }
 
   async addImplementationItemEvidence(implementationItemId, body) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/evidence`, {
-      method: 'POST', body,
-    });
+    return this.implementationEvidence.addImplementationItemEvidence(implementationItemId, body);
   }
 
   async addImplementationItemActivity(implementationItemId, body) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/activity`, {
-      method: 'POST', body,
-    });
+    return this.implementationEvidence.addImplementationItemActivity(implementationItemId, body);
   }
 
   async listImplementationItemActivity(implementationItemId) {
-    return this._request(`/api/governed-implementation/items/${implementationItemId}/activity`);
+    return this.implementationEvidence.listImplementationItemActivity(implementationItemId);
   }
 
   async updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, body) {
@@ -7253,23 +7172,19 @@ export class AIEngineClient {
   }
 
   async createImplementationPacketGateDecision(packetId, body) {
-    return this._request(`/api/governed-implementation/packets/${packetId}/gate-decisions`, {
-      method: 'POST', body,
-    });
+    return this.implementationGates.createImplementationPacketGateDecision(packetId, body);
   }
 
   async bindImplementationPacketToWorkflow(workflowId, body) {
-    return this._request(`/api/governed-implementation/workflows/${workflowId}/bindings`, {
-      method: 'POST', body,
-    });
+    return this.implementationPackets.bindImplementationPacketToWorkflow(workflowId, body);
   }
 
   async getWorkflowImplementationRoadmap(workflowId) {
-    return this._request(`/api/governed-implementation/workflows/${workflowId}/roadmap`);
+    return this.implementationPackets.getWorkflowImplementationRoadmap(workflowId);
   }
 
   async getWorkflowResumeContext(workflowId) {
-    return this._request(`/api/governed-implementation/workflows/${workflowId}/resume-context`);
+    return this.implementationPackets.getWorkflowResumeContext(workflowId);
   }
 
   async executeVerifiedMutation({

package/src/domains/implementation-artifacts.js

@@ -0,0 +1,6 @@
+export function createImplementationArtifactsDomain(client) {
+  return {
+    getArtifactManifest: (implementationItemId) => client._request(`/api/governed-implementation/items/${implementationItemId}/artifact-manifest`),
+    getDecisionPacket: (implementationItemId) => client._request(`/api/governed-implementation/items/${implementationItemId}/decision-packet`),
+  };
+}

package/src/domains/implementation-evidence.js

@@ -0,0 +1,13 @@
+export function createImplementationEvidenceDomain(client) {
+  return {
+    addImplementationItemEvidence: (implementationItemId, body) => client._request(`/api/governed-implementation/items/${implementationItemId}/evidence`, {
+      method: 'POST',
+      body,
+    }),
+    addImplementationItemActivity: (implementationItemId, body) => client._request(`/api/governed-implementation/items/${implementationItemId}/activity`, {
+      method: 'POST',
+      body,
+    }),
+    listImplementationItemActivity: (implementationItemId) => client._request(`/api/governed-implementation/items/${implementationItemId}/activity`),
+  };
+}

package/src/domains/implementation-gates.js

@@ -0,0 +1,9 @@
+export function createImplementationGatesDomain(client) {
+  return {
+    getImplementationItemAcceptanceChecks: (implementationItemId) => client._request(`/api/governed-implementation/items/${implementationItemId}/acceptance-checks`),
+    createImplementationPacketGateDecision: (packetId, body) => client._request(`/api/governed-implementation/packets/${packetId}/gate-decisions`, {
+      method: 'POST',
+      body,
+    }),
+  };
+}

package/src/domains/implementation-items.js

@@ -0,0 +1,107 @@
+export function createImplementationItemsDomain(client) {
+  return {
+    createImplementationTask: async (implementationItemId, {
+      title,
+      implementationPacketId,
+      description,
+      priority,
+      assignedTo,
+      assignedBy,
+      dueAt,
+      sortOrder,
+      notes,
+      createdBy,
+      parentTaskId,
+      claimId,
+      claimProjectId,
+      projectId,
+      claimedItemId,
+      workflowRunId,
+      agentSessionId,
+      allowedMutationSurfaces,
+      acknowledgedReminders,
+      executionIntent,
+      executionType,
+      executionPurpose,
+    } = {}) => {
+      const normalizedClaimId = String(claimId || '').trim() || null;
+      const normalizedClaimProjectId = String(claimProjectId || projectId || '').trim() || null;
+      const normalizedClaimedItemId = String(claimedItemId || implementationItemId || '').trim() || null;
+      const normalizedWorkflowRunId = String(workflowRunId || '').trim() || null;
+      const normalizedAgentSessionId = String(agentSessionId || '').trim() || null;
+      const normalizedAllowedMutationSurfaces = Array.isArray(allowedMutationSurfaces) && allowedMutationSurfaces.length > 0
+        ? allowedMutationSurfaces
+        : ['project_roadmap_task'];
+      const normalizedAcknowledgedReminders = Array.isArray(acknowledgedReminders)
+        ? acknowledgedReminders
+        : undefined;
+      const normalizedExecutionIntent = (() => {
+        if (executionIntent && typeof executionIntent === 'object') {
+          const execution_type = String(executionIntent.execution_type || executionIntent.executionType || '').trim();
+          const execution_purpose = String(executionIntent.execution_purpose || executionIntent.executionPurpose || '').trim();
+          if (execution_type || execution_purpose) {
+            return {
+              ...(execution_type ? { execution_type } : {}),
+              ...(execution_purpose ? { execution_purpose } : {}),
+            };
+          }
+        }
+        const normalizedExecutionType = String(executionType || '').trim() || 'implementation_task';
+        const normalizedExecutionPurpose = String(executionPurpose || title || '').trim() || 'implementation task';
+        return {
+          execution_type: normalizedExecutionType,
+          execution_purpose: normalizedExecutionPurpose,
+        };
+      })();
+      await client._assertExecutionEligibility({
+        claim_id: normalizedClaimId,
+        claim_project_id: normalizedClaimProjectId,
+        claimed_item_id: normalizedClaimedItemId,
+        workflow_run_id: normalizedWorkflowRunId,
+        agent_session_id: normalizedAgentSessionId,
+        allowed_mutation_surfaces: normalizedAllowedMutationSurfaces,
+        acknowledged_reminders: normalizedAcknowledgedReminders || [],
+        requested_mutation_surface: 'project_roadmap_task',
+        verification_required: true,
+      });
+      return client._request(`/api/operator/implementation-items/${implementationItemId}/tasks`, {
+        method: 'POST',
+        body: {
+          title,
+          implementation_packet_id: implementationPacketId,
+          description,
+          priority,
+          assigned_to: assignedTo,
+          assigned_by: assignedBy,
+          due_at: dueAt,
+          sort_order: sortOrder,
+          notes,
+          created_by: createdBy,
+          parent_task_id: parentTaskId,
+          claim_id: normalizedClaimId,
+          claim_project_id: normalizedClaimProjectId,
+          claimed_item_id: normalizedClaimedItemId,
+          workflow_run_id: normalizedWorkflowRunId,
+          agent_session_id: normalizedAgentSessionId,
+          allowed_mutation_surfaces: normalizedAllowedMutationSurfaces,
+          acknowledged_reminders: normalizedAcknowledgedReminders,
+          execution_intent: normalizedExecutionIntent,
+        },
+      });
+    },
+    listImplementationTasks: (implementationItemId) => client._request(`/api/operator/implementation-items/${implementationItemId}/tasks`),
+    listImplementationSubtasks: (taskId) => client._request(`/api/operator/implementation-item-tasks/${taskId}/subtasks`),
+    updateImplementationTask: (taskId, updates) => client._request(`/api/operator/implementation-item-tasks/${taskId}`, {
+      method: 'PATCH',
+      body: updates,
+    }),
+    assignImplementationTask: (taskId, request = {}) => client._request(`/api/operator/implementation-item-tasks/${taskId}/assign`, {
+      method: 'POST',
+      body: { assigned_to: request.assignedTo, assigned_by: request.assignedBy },
+    }),
+    completeImplementationTask: (taskId, request = {}) => client._request(`/api/operator/implementation-item-tasks/${taskId}/complete`, {
+      method: 'POST',
+      body: { completed_by: request.completedBy },
+    }),
+  };
+}

package/src/domains/implementation-packets.js

@@ -0,0 +1,15 @@
+export function createImplementationPacketsDomain(client) {
+  return {
+    importImplementationPacket: (body) => client._request('/api/governed-implementation/packets/import', { method: 'POST', body }),
+    listImplementationPackets: (request = {}) => client._request('/api/governed-implementation/packets', {
+      query: { status: request.status, packet_type: request.packetType },
+    }),
+    getImplementationPacket: (packetId) => client._request(`/api/governed-implementation/packets/${packetId}`),
+    bindImplementationPacketToWorkflow: (workflowId, body) => client._request(`/api/governed-implementation/workflows/${workflowId}/bindings`, {
+      method: 'POST',
+      body,
+    }),
+    getWorkflowImplementationRoadmap: (workflowId) => client._request(`/api/governed-implementation/workflows/${workflowId}/roadmap`),
+    getWorkflowResumeContext: (workflowId) => client._request(`/api/governed-implementation/workflows/${workflowId}/resume-context`),
+  };
+}

package/src/domains/project-chartering.js

@@ -0,0 +1,55 @@
+export function createProjectCharteringDomain(client) {
+  return {
+    createProjectDelivery: (body = {}) => client._request('/api/project-delivery', { method: 'POST', body }),
+    approveProjectCharterIntent: (projectId, body = {}) => {
+      if (!projectId) throw new Error('projectId is required.');
+      return client._request(`/api/project-delivery/${encodeURIComponent(projectId)}/approve-charter-intent`, {
+        method: 'POST',
+        body,
+      });
+    },
+    approveImplementationRoadmap: (projectId, body = {}) => {
+      if (!projectId) throw new Error('projectId is required.');
+      return client._request(`/api/project-delivery/${encodeURIComponent(projectId)}/approve-roadmap`, {
+        method: 'POST',
+        body,
+      });
+    },
+    runProjectCharter: (projectId, body = {}) => {
+      if (!projectId) throw new Error('projectId is required.');
+      return client._request(`/api/project-delivery/${encodeURIComponent(projectId)}/run-charter`, {
+        method: 'POST',
+        body,
+      });
+    },
+    beginImplementationRoadmap: (projectId, body = {}) => {
+      if (!projectId) throw new Error('projectId is required.');
+      return client._request(`/api/project-delivery/${encodeURIComponent(projectId)}/begin-roadmap`, {
+        method: 'POST',
+        body,
+      });
+    },
+    createProjectCharter: (request = {}) => client._request('/api/projects/charter', {
+      method: 'POST',
+      body: {
+        project_name: request.projectName,
+        objective: request.objective,
+        business_context: request.businessContext,
+        success_criteria: request.successCriteria,
+        priority: request.priority,
+        constraints: request.constraints ?? [],
+        in_scope: request.inScope ?? [],
+        out_of_scope: request.outOfScope ?? [],
+        assumptions: request.assumptions ?? [],
+        linked_workflows: request.linkedWorkflows ?? [],
+        linked_workflow_slug: request.linkedWorkflowSlug,
+        testing_strategy: request.testingStrategy ?? {},
+        initial_context: request.initialContext ?? {},
+        requested_by: request.requestedBy,
+        ensure_task_surface: request.ensureTaskSurface ?? true,
+        assigned_to: request.assignedTo,
+        create_acceptance_subtasks: request.createAcceptanceSubtasks ?? true,
+      },
+    }),
+  };
+}

package/src/domains/projects.js

@@ -0,0 +1,49 @@
+export function createProjectsDomain(client) {
+  return {
+    listProjects: (request) => client._request('/api/operator/projects', {
+      query: {
+        limit: request?.limit,
+        include_inactive: request?.includeInactive,
+        process_status: request?.processStatus,
+        charter_status: request?.charterStatus,
+      },
+    }),
+    getProject: (projectId) => client._request(`/api/operator/projects/${projectId}`),
+    listProjectWorkflowRuns: (projectId, request = {}) => client._request(`/api/operator/projects/${projectId}/workflow-runs`, {
+      query: { limit: request.limit ?? 25 },
+    }),
+    getProjectCharterReport: (projectId) => client._request(`/api/operator/projects/${projectId}/charter/report`),
+    createProjectMarkdownDownload: (projectId, request = {}) => client._request(`/api/operator/projects/${projectId}/markdown-report-downloads`, {
+      method: 'POST',
+      body: {
+        report_type: request.reportType,
+        include_markdown: request.includeMarkdown ?? false,
+      },
+    }),
+    downloadProjectMarkdownReport: (projectId, reportType) => client._requestText(`/api/operator/projects/${projectId}/markdown-reports/${reportType}/download`),
+    downloadProjectCharterReportMarkdown: (projectId) => client._requestText(`/api/operator/projects/${projectId}/markdown-reports/charter/download`),
+    getProjectBundle: (projectId) => client._request(`/api/operator/projects/${projectId}/bundle`),
+    resumeProjectWork: (request = {}) => {
+      const normalizedProjectIdentifier = String(request.projectIdentifier || request.projectId || '').trim();
+      if (!normalizedProjectIdentifier) {
+        throw new Error('projectIdentifier is required.');
+      }
+      return client._request(`/api/operator/projects/${encodeURIComponent(normalizedProjectIdentifier)}/resume-context`, {
+        query: {
+          actor_mode: request.actorMode,
+          execution_intent: request.executionIntent,
+          require_claim: request.requireClaim,
+          workflow_run_limit: request.workflowRunLimit,
+        },
+      });
+    },
+    listProjectOpenTasks: (projectId) => client._request(`/api/operator/projects/${projectId}/open-tasks`),
+    getProjectPerformanceMetrics: (projectId, request = {}) => client._request(`/api/operator/projects/${projectId}/performance-metrics`, {
+      query: {
+        workflow_id: request.workflowId,
+        workflow_run_id: request.workflowRunId,
+        since_utc: request.sinceUtc,
+      },
+    }),
+  };
+}

package/src/domains/roadmaps.js

@@ -0,0 +1,20 @@
+export function createRoadmapsDomain(client) {
+  return {
+    listProjectRoadmaps: (request = {}) => client._request('/api/operator/projects/implementation-roadmaps', {
+      query: { include_inactive: request.includeInactive },
+    }),
+    getProjectRoadmap: (projectId) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap`),
+    getProjectRoadmapSummary: (projectId) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap/summary`),
+    getProjectRoadmapActiveItem: (projectId) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap/active-item`),
+    getProjectImplementationRoadmapReport: (projectId) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap/report`),
+    downloadProjectImplementationRoadmapReportMarkdown: (projectId) => client._requestText(`/api/operator/projects/${projectId}/markdown-reports/implementation_roadmap/download`),
+    ensureProjectRoadmapTaskSurface: (projectId, request = {}) => client._request(`/api/operator/projects/${projectId}/implementation-roadmap/task-surface`, {
+      method: 'POST',
+      body: {
+        requested_by: request.requestedBy,
+        assigned_to: request.assignedTo,
+        create_acceptance_subtasks: request.createAcceptanceSubtasks ?? true,
+      },
+    }),
+  };
+}

package/src/index.js

@@ -1,5 +1,5 @@
 export { AIEngineClient, createAIEngineClient } from './client.js';
-export const AI_ENGINE_CLIENT_VERSION = '1.1.74';
+export const AI_ENGINE_CLIENT_VERSION = '1.1.75';
 export { GOVERNED_MUTATION_REQUIRED_CAPABILITIES, AI_ENGINE_CLIENT_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
 export { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
 export {