@a5c-ai/kradle 5.0.1-staging.3abdf9534c25

package/src/agent-permission-review.js

@@ -0,0 +1,250 @@
+import { createHash } from 'node:crypto';
+import { clone } from './resource-model.js';
+
+export const AGENT_PERMISSION_REVIEW_BOUNDARY = {
+  role: 'agent-permission-review',
+  scope: 'Deterministic permission review for agent dispatch decisions',
+  owns: ['capability expansion', 'grant resolution', 'permission snapshot creation'],
+  delegatesTo: ['resource-model'],
+  mustNotOwn: ['secret values', 'native K8s API calls', 'runtime execution']
+};
+
+const VALID_APPROVAL_MODES = new Set(['yolo', 'prompt', 'deny']);
+
+export function createPermissionReviewer(options = {}) {
+  return {
+    role: 'agent-permission-review',
+
+    reviewPermissions({ repository, ref, actor, agentStack, triggerSource, taskKind, runnerPool, toolRefs = [], skillRefs = [], mcpServerRefs = [], contextLabelRefs = [], workspacePolicyRef, isFork = false, resources = {} }) {
+      const reasons = [];
+      const grants = [];
+      const crossOrgDenials = [];
+      const untrustedForkWarnings = [];
+
+      // Step 1 — Resolve AgentStack
+      const stacks = resources.AgentStack || [];
+      const stack = stacks.find((s) => s.metadata?.name === agentStack);
+      if (!stack) {
+        return buildDecision({ decision: 'denied', reasons: [{ severity: 'error', message: `AgentStack not found: ${agentStack}` }], grants, capabilities: {}, actor, repository, ref, agentStack, taskKind, crossOrgDenials, untrustedForkWarnings });
+      }
+
+      // Step 1a — Validate approvalMode
+      const approvalMode = stack.spec?.approvalMode;
+      if (approvalMode !== undefined && !VALID_APPROVAL_MODES.has(approvalMode)) {
+        reasons.push({ severity: 'error', message: `Invalid approvalMode '${approvalMode}': must be one of ${[...VALID_APPROVAL_MODES].join(', ')}` });
+      }
+
+      // Step 1b — Deny mode blocks everything immediately
+      if (approvalMode === 'deny') {
+        reasons.push({ severity: 'error', message: `approvalMode is 'deny': all requests are blocked by policy` });
+        return buildDecision({ decision: 'denied', reasons, grants, capabilities: {}, actor, repository, ref, agentStack, taskKind, approvalMode, crossOrgDenials, untrustedForkWarnings });
+      }
+
+      // Step 2 — Cross-org denial check
+      const agentOrg = stack.spec?.organizationRef;
+      if (agentOrg && repository) {
+        // repository format: '<org>/<repo>' or just '<repo>'
+        const repoParts = repository.split('/');
+        const repoOrg = repoParts.length >= 2 ? repoParts[0] : null;
+        if (repoOrg && repoOrg !== agentOrg) {
+          crossOrgDenials.push({ agentOrg, resourceOrg: repoOrg, resource: repository });
+          reasons.push({ severity: 'error', message: `Cross-org access denied: agent org '${agentOrg}' cannot access repository in org '${repoOrg}'` });
+        }
+      }
+
+      // Step 3 — Expand capabilities from stack spec
+      const capabilities = {
+        toolRefs: clone(stack.spec?.toolPolicy ? [stack.spec.toolPolicy] : toolRefs),
+        mcpServerRefs: clone(stack.spec?.mcpServerRefs || mcpServerRefs),
+        skillRefs: clone(stack.spec?.skillRefs || skillRefs),
+        subagentRefs: clone(stack.spec?.subagentRefs || [])
+      };
+
+      // Step 4 — Untrusted fork detection
+      const isForkRef = isFork || /^refs\/pull\/\d+\//.test(ref);
+      if (isForkRef) {
+        const blockedKinds = ['AgentServiceAccount', 'AgentSecretGrant'];
+        untrustedForkWarnings.push({
+          ref,
+          isFork: true,
+          blockedKinds,
+          message: `Untrusted fork detected for ref '${ref}': privileged grants restricted`
+        });
+        reasons.push({ severity: 'warning', message: `Untrusted fork detected for ref '${ref}': privileged grants (${blockedKinds.join(', ')}) are not auto-approved` });
+      }
+
+      // Step 5 — Check runtime identity (AgentServiceAccount)
+      const serviceAccountRef = stack.spec?.runtimeIdentity?.serviceAccountRef || stack.spec?.runtimeIdentity;
+      const serviceAccounts = resources.AgentServiceAccount || [];
+      const serviceAccount = serviceAccounts.find((sa) => sa.metadata?.name === serviceAccountRef);
+      if (!serviceAccount) {
+        reasons.push({ severity: 'error', message: `Missing AgentServiceAccount: ${serviceAccountRef}` });
+      } else {
+        const saGrant = { kind: 'AgentServiceAccount', name: serviceAccount.metadata.name, status: 'bound' };
+        if (isForkRef) {
+          saGrant.status = 'fork-restricted';
+        }
+        grants.push(saGrant);
+      }
+
+      // Step 6 — Check role bindings
+      const roleBindings = resources.AgentRoleBinding || [];
+      const matchedBindings = roleBindings.filter((rb) => rb.spec?.subject === serviceAccountRef || rb.spec?.subject === agentStack);
+      for (const binding of matchedBindings) {
+        grants.push({ kind: 'AgentRoleBinding', name: binding.metadata.name, roleRef: binding.spec?.roleRef, scope: binding.spec?.scope, status: 'bound' });
+      }
+      if (matchedBindings.length === 0 && serviceAccount) {
+        reasons.push({ severity: 'warning', message: `No AgentRoleBinding found for subject: ${serviceAccountRef}` });
+      }
+
+      // Step 7 — Check secret grants
+      const secretGrants = resources.AgentSecretGrant || [];
+      const neededSecrets = collectSecretNeeds(stack, capabilities, resources);
+      for (const need of neededSecrets) {
+        const match = secretGrants.find((sg) => {
+          if (sg.spec?.subject !== serviceAccountRef && sg.spec?.subject !== agentStack) return false;
+          if (need.purpose && sg.spec?.purpose !== need.purpose) return false;
+          if (sg.spec?.allowedRepositories && sg.spec.allowedRepositories.length > 0 && !sg.spec.allowedRepositories.includes(repository)) return false;
+          if (sg.spec?.allowedRefs && sg.spec.allowedRefs.length > 0 && !sg.spec.allowedRefs.includes(ref)) return false;
+          return true;
+        });
+        if (!match) {
+          reasons.push({ severity: 'error', message: `Missing AgentSecretGrant for ${need.description} (purpose: ${need.purpose})` });
+        } else {
+          const grantEntry = { kind: 'AgentSecretGrant', name: match.metadata.name, purpose: match.spec?.purpose, status: 'granted' };
+          if (isForkRef) {
+            grantEntry.status = 'fork-restricted';
+          } else if (match.spec?.requiredApproval) {
+            grantEntry.status = 'requires-approval';
+            grantEntry.requiredApproval = match.spec.requiredApproval;
+            reasons.push({ severity: 'info', message: `AgentSecretGrant ${match.metadata.name} requires approval: ${match.spec.requiredApproval}` });
+          }
+          grants.push(grantEntry);
+        }
+      }
+
+      // Step 8 — Check config grants
+      const configGrants = resources.AgentConfigGrant || [];
+      const neededConfigs = collectConfigNeeds(stack, capabilities, resources);
+      for (const need of neededConfigs) {
+        const match = configGrants.find((cg) => {
+          if (cg.spec?.subject !== serviceAccountRef && cg.spec?.subject !== agentStack) return false;
+          if (need.purpose && cg.spec?.purpose !== need.purpose) return false;
+          return true;
+        });
+        if (!match) {
+          reasons.push({ severity: 'error', message: `Missing AgentConfigGrant for ${need.description} (purpose: ${need.purpose})` });
+        } else {
+          grants.push({ kind: 'AgentConfigGrant', name: match.metadata.name, purpose: match.spec?.purpose, status: 'granted' });
+        }
+      }
+
+      // Step 9 — Workspace policy enforcement
+      if (workspacePolicyRef) {
+        const policies = resources.KradleWorkspacePolicy || [];
+        const policy = policies.find((p) => p.metadata?.name === workspacePolicyRef);
+        if (policy) {
+          // Check maxConcurrentSessions
+          if (policy.spec?.maxConcurrentSessions === 0) {
+            reasons.push({ severity: 'error', message: `Workspace policy '${workspacePolicyRef}' maxConcurrentSessions is 0: no sessions allowed` });
+          }
+          // Check deniedTools
+          const deniedTools = policy.spec?.deniedTools || [];
+          const requestedTools = capabilities.toolRefs;
+          for (const tool of requestedTools) {
+            if (deniedTools.includes(tool)) {
+              reasons.push({ severity: 'error', message: `Tool '${tool}' is denied by workspace policy '${workspacePolicyRef}'` });
+            }
+          }
+          // Check allowedTools (if specified, only those tools are permitted)
+          const allowedTools = policy.spec?.allowedTools;
+          if (allowedTools && allowedTools.length > 0) {
+            for (const tool of requestedTools) {
+              if (!allowedTools.includes(tool)) {
+                reasons.push({ severity: 'error', message: `Tool '${tool}' is not in allowedTools for workspace policy '${workspacePolicyRef}'` });
+              }
+            }
+          }
+        }
+      }
+
+      // Step 10 — Decision
+      const hasErrors = reasons.some((r) => r.severity === 'error');
+      const hasApprovals = grants.some((g) => g.status === 'requires-approval');
+      let decision;
+      if (hasErrors) {
+        decision = 'denied';
+      } else if (hasApprovals) {
+        decision = 'requires-approval';
+      } else {
+        decision = 'allowed';
+      }
+
+      return buildDecision({ decision, reasons, grants, capabilities, actor, repository, ref, agentStack, taskKind, approvalMode, crossOrgDenials, untrustedForkWarnings });
+    },
+
+    createPermissionSnapshot(reviewResult) {
+      const snapshot = clone(reviewResult);
+      snapshot.snapshotAt = new Date().toISOString();
+      snapshot.frozen = true;
+      snapshot.digest = reviewResult.digest;
+      return Object.freeze(snapshot);
+    }
+  };
+}
+
+function collectSecretNeeds(stack, capabilities, resources) {
+  const needs = [];
+  if (stack.spec?.adapter) {
+    needs.push({ description: `model provider for adapter ${stack.spec.adapter}`, purpose: 'model-provider' });
+  }
+  const mcpServers = resources.AgentMcpServer || [];
+  for (const ref of capabilities.mcpServerRefs) {
+    const server = mcpServers.find((s) => s.metadata?.name === ref);
+    if (server?.spec?.secretRef) {
+      needs.push({ description: `MCP server ${ref} secret`, purpose: `mcp-server:${ref}` });
+    }
+  }
+  return needs;
+}
+
+function collectConfigNeeds(stack, capabilities, resources) {
+  const needs = [];
+  const mcpServers = resources.AgentMcpServer || [];
+  for (const ref of capabilities.mcpServerRefs) {
+    const server = mcpServers.find((s) => s.metadata?.name === ref);
+    if (server?.spec?.configMapRef) {
+      needs.push({ description: `MCP server ${ref} config`, purpose: `mcp-server:${ref}` });
+    }
+  }
+  return needs;
+}
+
+function buildDecision({ decision, reasons, grants, capabilities, actor, repository, ref, agentStack, taskKind, approvalMode, crossOrgDenials = [], untrustedForkWarnings = [] }) {
+  const result = {
+    decision,
+    actor,
+    repository,
+    ref,
+    agentStack,
+    taskKind,
+    capabilities: clone(capabilities),
+    grants: clone(grants),
+    reasons: clone(reasons),
+    crossOrgDenials: clone(crossOrgDenials),
+    untrustedForkWarnings: clone(untrustedForkWarnings),
+    reviewedAt: new Date().toISOString()
+  };
+  if (approvalMode !== undefined) {
+    result.approvalMode = approvalMode;
+  }
+  result.digest = computeDigest(result);
+  return result;
+}
+
+function computeDigest(result) {
+  const keys = Object.keys(result).filter((k) => k !== 'digest' && k !== 'reviewedAt').sort();
+  const canonical = {};
+  for (const key of keys) canonical[key] = result[key];
+  return createHash('sha256').update(JSON.stringify(canonical)).digest('hex');
+}

package/src/agent-persona-controller.js

@@ -0,0 +1,135 @@
+import { clone, createResource } from './resource-model.js';
+
+export const AGENT_PERSONA_CONTROLLER_BOUNDARY = {
+  role: 'agent-persona-controller',
+  scope: 'Agent identity validation and resolution for personas, definitions, souls, appearance, and voice profiles',
+  owns: ['agent identity reference resolution', 'agent profile validation'],
+  delegatesTo: ['resource-model', 'agent-prompt-composition'],
+  mustNotOwn: ['runtime job creation', 'permission review']
+};
+
+function findByName(resources, kind, name, organizationRef) {
+  return (resources?.[kind] || []).find((resource) => {
+    if (resource.metadata?.name !== name) return false;
+    return !organizationRef || !resource.spec?.organizationRef || resource.spec.organizationRef === organizationRef;
+  }) || null;
+}
+
+function required(resource, fields) {
+  const errors = [];
+  for (const field of fields) {
+    const value = resource?.spec?.[field];
+    if (value === undefined || value === null || value === '') errors.push(`spec.${field} is required`);
+  }
+  return errors;
+}
+
+export function validateAgentPersona(resource) {
+  const errors = required(resource, ['organizationRef', 'displayName']);
+  if (resource?.kind && resource.kind !== 'AgentPersona') errors.push('kind must be AgentPersona');
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateAgentDefinition(resource) {
+  const errors = required(resource, ['organizationRef', 'personaRef', 'stackRef']);
+  if (resource?.kind && resource.kind !== 'AgentDefinition') errors.push('kind must be AgentDefinition');
+  return { valid: errors.length === 0, errors };
+}
+
+function inlineResource(kind, name, namespace, organizationRef, spec) {
+  return createResource(kind, { name, namespace }, { organizationRef, ...(spec || {}) });
+}
+
+function resolveProfileRef({ resources, kind, ref, organizationRef, errors }) {
+  if (!ref) return null;
+  const found = findByName(resources, kind, ref, organizationRef);
+  if (!found) errors.push(`${kind} not found: ${ref}`);
+  return found;
+}
+
+export function resolveAgentPersona(personaRef, { resources = {}, organizationRef = 'default' } = {}) {
+  const errors = [];
+  const persona = typeof personaRef === 'string' ? findByName(resources, 'AgentPersona', personaRef, organizationRef) : personaRef;
+  if (!persona) {
+    return { error: true, persona: null, soul: null, appearance: null, voiceProfile: null, errors: [`AgentPersona not found: ${personaRef}`] };
+  }
+
+  const validation = validateAgentPersona(persona);
+  errors.push(...validation.errors);
+
+  const namespace = persona.metadata?.namespace || 'default';
+  const name = persona.metadata?.name || 'agent';
+  const spec = persona.spec || {};
+
+  let soul = null;
+  if (spec.soul?.inline) {
+    soul = inlineResource('AgentSoul', `${name}-inline-soul`, namespace, spec.organizationRef || organizationRef, { personaRef: name, content: spec.soul.inline });
+  } else if (spec.soul?.ref) {
+    soul = resolveProfileRef({ resources, kind: 'AgentSoul', ref: spec.soul.ref, organizationRef, errors });
+  }
+
+  let appearance = null;
+  if (spec.appearance?.inline) {
+    appearance = inlineResource('AgentAppearance', `${name}-inline-appearance`, namespace, spec.organizationRef || organizationRef, { personaRef: name, ...spec.appearance.inline });
+  } else if (spec.appearance?.ref) {
+    appearance = resolveProfileRef({ resources, kind: 'AgentAppearance', ref: spec.appearance.ref, organizationRef, errors });
+  }
+
+  let voiceProfile = null;
+  if (spec.voiceProfile?.inline) {
+    voiceProfile = inlineResource('AgentVoiceProfile', `${name}-inline-voice`, namespace, spec.organizationRef || organizationRef, { personaRef: name, ...spec.voiceProfile.inline });
+  } else if (spec.voiceProfile?.ref) {
+    voiceProfile = resolveProfileRef({ resources, kind: 'AgentVoiceProfile', ref: spec.voiceProfile.ref, organizationRef, errors });
+  }
+
+  return { error: errors.length > 0, persona, soul, appearance, voiceProfile, errors };
+}
+
+export function resolveAgentDefinition(definitionRef, { resources = {}, organizationRef = 'default' } = {}) {
+  const errors = [];
+  const definition = typeof definitionRef === 'string' ? findByName(resources, 'AgentDefinition', definitionRef, organizationRef) : definitionRef;
+  if (!definition) {
+    return { error: true, definition: null, persona: null, soul: null, appearance: null, voiceProfile: null, stack: null, errors: [`AgentDefinition not found: ${definitionRef}`] };
+  }
+
+  const validation = validateAgentDefinition(definition);
+  errors.push(...validation.errors);
+  const resolvedPersona = resolveAgentPersona(definition.spec?.personaRef, { resources, organizationRef: definition.spec?.organizationRef || organizationRef });
+  errors.push(...resolvedPersona.errors);
+
+  const stackRef = definition.spec?.stackRef;
+  const stack = stackRef ? findByName(resources, 'AgentStack', stackRef, definition.spec?.organizationRef || organizationRef) : null;
+  if (stackRef && !stack) errors.push(`AgentStack not found: ${stackRef}`);
+
+  return {
+    error: errors.length > 0,
+    definition,
+    persona: resolvedPersona.persona,
+    soul: resolvedPersona.soul,
+    appearance: resolvedPersona.appearance,
+    voiceProfile: resolvedPersona.voiceProfile,
+    stack,
+    errors,
+  };
+}
+
+export function createAgentPersonaController() {
+  return {
+    role: 'agent-persona-controller',
+    validateAgentPersona,
+    validateAgentDefinition,
+    resolveAgentPersona,
+    resolveAgentDefinition,
+    summarizeProfile(resolved) {
+      return {
+        definition: clone(resolved.definition),
+        persona: clone(resolved.persona),
+        soul: clone(resolved.soul),
+        appearance: clone(resolved.appearance),
+        voiceProfile: clone(resolved.voiceProfile),
+        stack: clone(resolved.stack),
+        errors: clone(resolved.errors || []),
+      };
+    }
+  };
+}

package/src/agent-project-controller.js

@@ -0,0 +1,117 @@
+// Agent Project Controller — Slice 1.2d
+// Manages KradleProject resources: validation, workflow columns, board state, and issue assignment.
+
+export const AGENT_PROJECT_CONTROLLER_BOUNDARY = {
+  role: 'agent-project-controller',
+  scope: 'KradleProject lifecycle: validation, workflow column definitions, board state management, issue assignment tracking',
+  owns: ['project validation', 'workflow columns', 'board state', 'default column resolution', 'issue assignment tracking'],
+  delegatesTo: ['resource-model'],
+  mustNotOwn: ['issue content', 'PR lifecycle', 'dispatch execution', 'Agent Mux sessions']
+};
+
+const VALID_BOARD_STATES = ['active', 'archived'];
+
+/**
+ * Validate a KradleProject resource. Returns { valid, errors }.
+ * @param {object} resource
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateAgentProject(resource) {
+  const errors = [];
+
+  // Guard against null/undefined resource
+  if (resource == null) {
+    errors.push('resource must not be null or undefined');
+    return { valid: false, errors };
+  }
+
+  // Validate metadata.name
+  if (!resource?.metadata?.name) {
+    errors.push('metadata.name is required');
+  }
+
+  const spec = resource?.spec || {};
+
+  // Validate organizationRef
+  if (!spec.organizationRef) {
+    errors.push('spec.organizationRef is required');
+  }
+
+  // Validate workflowColumns — must be a non-empty array
+  const cols = spec.workflowColumns;
+  if (!Array.isArray(cols) || cols.length === 0) {
+    errors.push('spec.workflowColumns must be a non-empty array');
+  } else {
+    // Check for duplicate column IDs
+    const seen = new Set();
+    for (const col of cols) {
+      if (seen.has(col.id)) {
+        errors.push(`spec.workflowColumns contains duplicate column ID: "${col.id}"`);
+        break;
+      }
+      seen.add(col.id);
+    }
+  }
+
+  // Validate boardState if explicitly set
+  const boardState = spec.boardState;
+  if (boardState != null && !VALID_BOARD_STATES.includes(boardState)) {
+    errors.push(`spec.boardState "${boardState}" is not supported; valid states are: ${VALID_BOARD_STATES.join(', ')}`);
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Factory that returns a KradleProject controller instance.
+ */
+export function createAgentProjectController() {
+  return {
+    role: 'agent-project-controller',
+
+    /**
+     * Validate a KradleProject resource.
+     * @param {object} resource
+     * @returns {{ valid: boolean, errors: string[] }}
+     */
+    validate(resource) {
+      return validateAgentProject(resource);
+    },
+
+    /**
+     * Return the workflow columns for a project, in order.
+     * @param {object} resource
+     * @returns {Array<{ id: string, displayName: string, color: string, default?: boolean }>}
+     */
+    getWorkflowColumns(resource) {
+      const cols = resource?.spec?.workflowColumns;
+      if (!Array.isArray(cols)) {
+        return [];
+      }
+      return [...cols];
+    },
+
+    /**
+     * Return the default column — the one marked `default: true`, or the first column.
+     * @param {object} resource
+     * @returns {{ id: string, displayName: string, color: string, default?: boolean } | undefined}
+     */
+    getDefaultColumn(resource) {
+      const cols = Array.isArray(resource?.spec?.workflowColumns)
+        ? resource.spec.workflowColumns
+        : [];
+      const marked = cols.find((c) => c.default === true);
+      return marked ?? cols[0];
+    },
+
+    /**
+     * Return the board state for a project.
+     * Defaults to 'active' when spec.boardState is not set.
+     * @param {object} resource
+     * @returns {string}
+     */
+    getBoardState(resource) {
+      return resource?.spec?.boardState ?? 'active';
+    }
+  };
+}

package/src/agent-prompt-composition.js

@@ -0,0 +1,55 @@
+function addPart(parts, value) {
+  if (typeof value === 'string' && value.trim()) parts.push(value.trim());
+}
+
+function joinList(values) {
+  return Array.isArray(values) && values.length > 0 ? values.join(', ') : null;
+}
+
+export function composeAgentSystemPrompt({ soul = null, persona = null, definition = null, stack = null } = {}) {
+  const parts = [];
+  addPart(parts, soul?.spec?.content);
+
+  const personaSpec = persona?.spec || {};
+  const personaParts = [];
+  addPart(personaParts, personaSpec.displayName);
+  addPart(personaParts, personaSpec.tagline);
+
+  const personality = personaSpec.personality || {};
+  const personalityParts = [];
+  if (personality.communicationStyle) personalityParts.push(`Communication style: ${personality.communicationStyle}`);
+  if (personality.tone) personalityParts.push(`Tone: ${personality.tone}`);
+  if (personality.explanationDepth) personalityParts.push(`Explanation depth: ${personality.explanationDepth}`);
+  if (personality.humorLevel) personalityParts.push(`Humor level: ${personality.humorLevel}`);
+  if (personality.language) personalityParts.push(`Language: ${personality.language}`);
+  const traits = joinList(personality.traits);
+  if (traits) personalityParts.push(`Traits: ${traits}`);
+  addPart(personaParts, personalityParts.join('. '));
+
+  const role = personaSpec.role || {};
+  const roleParts = [];
+  if (role.title) roleParts.push(`Role: ${role.title}`);
+  if (role.domain) roleParts.push(`Domain: ${role.domain}`);
+  const expertise = joinList(role.expertise);
+  if (expertise) roleParts.push(`Expertise: ${expertise}`);
+  addPart(personaParts, roleParts.join('. '));
+
+  const skills = joinList(personaSpec.skillRefs);
+  if (skills) personaParts.push(`Skills: ${skills}`);
+  const knowledge = joinList(personaSpec.knowledgeRefs);
+  if (knowledge) personaParts.push(`Knowledge: ${knowledge}`);
+  addPart(parts, personaParts.join('\n'));
+
+  addPart(parts, definition?.spec?.roleContext);
+  addPart(parts, stack?.spec?.systemPrompt);
+  return parts.join('\n\n');
+}
+
+export function composeAgentPrompt({ soul = null, persona = null, definition = null, stack = null } = {}) {
+  const legacyPrompts = persona?.spec?.legacyPrompts || {};
+  return {
+    system: composeAgentSystemPrompt({ soul, persona, definition, stack }) || null,
+    developer: legacyPrompts.developerPrompt || stack?.spec?.developerPrompt || null,
+    task: legacyPrompts.taskPrompt || stack?.spec?.taskPrompt || null,
+  };
+}