@karajan-family/code 4.21.0

package/src/planning-game/adapter.js

@@ -0,0 +1,108 @@
+/**
+ * Planning Game MCP adapter.
+ * Handles card ID detection, task enrichment, and completion updates.
+ */
+
+const CARD_ID_PATTERN = /[A-Z0-9]{2,5}-(?:TSK|BUG|PCS|PRP|SPR|QA)-\d{4}/;
+
+export function parseCardId(text) {
+  if (!text) return null;
+  const match = CARD_ID_PATTERN.exec(String(text));
+  return match ? match[0] : null;
+}
+
+function appendDescriptionSection(parts, card) {
+  if (card.descriptionStructured?.length) {
+    parts.push("", "### User Story");
+    for (const s of card.descriptionStructured) {
+      parts.push(`- **Como** ${s.role}`, `  **Quiero** ${s.goal}`, `  **Para** ${s.benefit}`);
+    }
+  } else if (card.description) {
+    parts.push("", "### Description", card.description);
+  }
+}
+
+function appendAcceptanceCriteriaSection(parts, card) {
+  if (card.acceptanceCriteriaStructured?.length) {
+    parts.push("", "### Acceptance Criteria");
+    for (const ac of card.acceptanceCriteriaStructured) {
+      if (ac.given && ac.when && ac.then) {
+        parts.push(`- **Given** ${ac.given}`, `  **When** ${ac.when}`, `  **Then** ${ac.then}`);
+      } else if (ac.raw) {
+        parts.push(`- ${ac.raw}`);
+      }
+    }
+  } else if (card.acceptanceCriteria) {
+    parts.push("", "### Acceptance Criteria", card.acceptanceCriteria);
+  }
+}
+
+function appendImplementationPlanSection(parts, card) {
+  if (!card.implementationPlan) return;
+  const plan = card.implementationPlan;
+  parts.push("", "### Implementation Plan");
+  if (plan.approach) parts.push(`**Approach:** ${plan.approach}`);
+  if (plan.steps?.length) {
+    parts.push("**Steps:**");
+    for (const step of plan.steps) {
+      parts.push(`1. ${step.description}`);
+    }
+  }
+}
+
+export function buildTaskFromCard(card) {
+  const parts = [`## ${card.cardId}: ${card.title}`];
+  appendDescriptionSection(parts, card);
+  appendAcceptanceCriteriaSection(parts, card);
+  appendImplementationPlanSection(parts, card);
+  return parts.join("\n");
+}
+
+export function buildCommitsPayload(gitLog) {
+  if (!gitLog?.length) return [];
+  return gitLog.map((entry) => ({
+    hash: entry.hash,
+    message: entry.message,
+    date: entry.date,
+    author: entry.author
+  }));
+}
+
+export function buildCompletionUpdates({ approved, commits, startDate, codeveloper }) {
+  if (!approved) return {};
+
+  const updates = {
+    status: "To Validate",
+    endDate: new Date().toISOString(),
+    developer: "dev_016",
+    commits: commits || []
+  };
+
+  if (startDate) updates.startDate = startDate;
+  if (codeveloper) updates.codeveloper = codeveloper;
+
+  return updates;
+}
+
+export function buildTaskPrompt({ task, card }) {
+  const cardId = parseCardId(task) || card?.cardId || null;
+  const prompt = card ? buildTaskFromCard(card) : task;
+  return { cardId, prompt };
+}
+
+export async function updateCardOnCompletion({
+  client,
+  projectId,
+  cardId,
+  firebaseId,
+  approved,
+  gitLog,
+  startDate,
+  codeveloper
+}) {
+  if (!approved) return null;
+
+  const commits = buildCommitsPayload(gitLog);
+  const updates = buildCompletionUpdates({ approved, commits, startDate, codeveloper });
+  return client.updateCard({ projectId, cardId, firebaseId, updates });
+}

package/src/planning-game/architect-adrs.js

@@ -0,0 +1,45 @@
+/**
+ * Automatic ADR generation from architect tradeoffs.
+ * Creates ADRs in Planning Game when PG is linked, or returns suggestions otherwise.
+ */
+
+function buildAdr({ tradeoff, taskTitle }) {
+  return {
+    title: tradeoff,
+    status: "accepted",
+    context: `Architecture decision for task: ${taskTitle}`,
+    decision: tradeoff
+  };
+}
+
+export async function createArchitectADRs({ tradeoffs, pgTaskId, pgProject, taskTitle, mcpClient }) {
+  if (!tradeoffs?.length) {
+    return { created: 0, adrs: [] };
+  }
+
+  const hasPg = Boolean(pgTaskId && pgProject && mcpClient);
+
+  if (!hasPg) {
+    const adrs = tradeoffs.map(tradeoff => ({
+      ...buildAdr({ tradeoff, taskTitle }),
+      suggestion: true
+    }));
+    return { created: 0, adrs };
+  }
+
+  const adrs = [];
+  let created = 0;
+
+  for (const tradeoff of tradeoffs) {
+    const adr = buildAdr({ tradeoff, taskTitle });
+    try {
+      await mcpClient.createAdr({ projectId: pgProject, adr });
+      adrs.push(adr);
+      created++;
+    } catch {
+      // Log warning but don't block pipeline for a single ADR failure
+    }
+  }
+
+  return { created, adrs };
+}

package/src/planning-game/client.js

@@ -0,0 +1,108 @@
+/**
+ * Planning Game MCP client.
+ * Communicates with Planning Game via HTTP API or MCP tool calls.
+ *
+ * When Karajan runs as an MCP server (kj_run), the caller (Claude Code)
+ * is expected to provide card data directly via pgTask/pgProject flags.
+ *
+ * This client provides standalone HTTP access for CLI usage (kj run --pg-task).
+ * Requires planning_game.api_url in config or PG_API_URL env var.
+ */
+
+import { withRetry } from "../utils/retry.js";
+
+const DEFAULT_API_URL = "http://localhost:3000/api";
+const DEFAULT_TIMEOUT_MS = 10000;
+
+function getApiUrl() {
+  return process.env.PG_API_URL || DEFAULT_API_URL;
+}
+
+async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    if (!response.ok) {
+      const err = new Error(`Planning Game API error: ${response.status} ${response.statusText}`);
+      err.httpStatus = response.status;
+      err.retryAfter = response.headers?.get?.("retry-after") || null;
+      throw err;
+    }
+    return response;
+  } catch (error) {
+    if (error?.httpStatus) throw error;
+    if (error?.name === "AbortError") {
+      const err = new Error(`Planning Game API timeout after ${timeoutMs}ms`);
+      err.httpStatus = 408;
+      throw err;
+    }
+    throw new Error(`Planning Game network error: ${error?.message || "unknown error"}`, { cause: error });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function fetchWithRetry(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS, retryOpts = {}) {
+  return withRetry(
+    () => fetchWithTimeout(url, options, timeoutMs),
+    { maxAttempts: 3, initialBackoffMs: 1000, ...retryOpts }
+  );
+}
+
+async function parseJsonResponse(response) {
+  try {
+    return await response.json();
+  } catch (error) {
+    throw new Error(`Planning Game invalid response: ${error?.message || "invalid JSON"}`, { cause: error });
+  }
+}
+
+export async function fetchCard({ projectId, cardId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(cardId)}`;
+  const response = await fetchWithRetry(url, {}, timeoutMs);
+  const data = await parseJsonResponse(response);
+  return data?.card || data;
+}
+
+export async function updateCard({ projectId, cardId: _cardId, firebaseId, updates, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/${encodeURIComponent(firebaseId)}`;
+  const response = await fetchWithRetry(
+    url,
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ updates })
+    },
+    timeoutMs
+  );
+  return parseJsonResponse(response);
+}
+
+export async function createCard({ projectId, card, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards`;
+  const response = await fetchWithRetry(
+    url,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(card)
+    },
+    timeoutMs
+  );
+  return parseJsonResponse(response);
+}
+
+export async function relateCards({ projectId, sourceCardId, targetCardId, relationType, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/relate`;
+  const response = await fetchWithRetry(
+    url,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sourceCardId, targetCardId, relationType })
+    },
+    timeoutMs
+  );
+  return parseJsonResponse(response);
+}

package/src/planning-game/decomposition.js

@@ -0,0 +1,87 @@
+/**
+ * Planning Game decomposition.
+ * Creates subtask cards in PG with blocks/blockedBy chain when triage
+ * recommends decomposition and user accepts.
+ */
+
+import { msg } from "../utils/messages.js";
+
+export async function createDecompositionSubtasks({
+  client,
+  projectId,
+  parentCardId,
+  parentFirebaseId: _parentFirebaseId,
+  subtasks,
+  epic,
+  sprint,
+  codeveloper
+}) {
+  if (!subtasks?.length || subtasks.length < 2) return [];
+
+  const created = [];
+
+  for (let i = 0; i < subtasks.length; i++) {
+    const card = {
+      type: "task",
+      title: subtasks[i],
+      descriptionStructured: [{
+        role: "developer",
+        goal: subtasks[i],
+        benefit: `Part ${i + 1}/${subtasks.length} of decomposed task ${parentCardId}`
+      }],
+      acceptanceCriteria: `Subtask ${i + 1} of ${parentCardId}: ${subtasks[i]}`
+    };
+
+    if (epic) card.epic = epic;
+    if (sprint) card.sprint = sprint;
+    if (codeveloper) card.codeveloper = codeveloper;
+
+    const result = await client.createCard({ projectId, card });
+    created.push({
+      cardId: result.cardId,
+      firebaseId: result.firebaseId,
+      title: subtasks[i],
+      index: i
+    });
+  }
+
+  // Chain blocks/blockedBy relationships: card[0] blocks card[1], card[1] blocks card[2], etc.
+  for (let i = 0; i < created.length - 1; i++) {
+    await client.relateCards({
+      projectId,
+      sourceCardId: created[i].cardId,
+      targetCardId: created[i + 1].cardId,
+      relationType: "blocks"
+    });
+  }
+
+  // Relate all subtasks to parent
+  for (const sub of created) {
+    await client.relateCards({
+      projectId,
+      sourceCardId: parentCardId,
+      targetCardId: sub.cardId,
+      relationType: "related"
+    });
+  }
+
+  return created;
+}
+
+export function buildDecompositionQuestion(subtasks, parentCardId, lang = "en") {
+  const lines = [
+    msg("triage_decompose", lang, { count: subtasks.length }),
+    ""
+  ];
+  for (let i = 0; i < subtasks.length; i++) {
+    lines.push(`${i + 1}. ${subtasks[i]}`);
+  }
+  lines.push(
+    "",
+    msg("triage_create_cards", lang, { cardId: parentCardId }),
+    msg("triage_sequential", lang),
+    "",
+    msg("triage_reply", lang)
+  );
+  return lines.join("\n");
+}

package/src/planning-game/pipeline-adapter.js

@@ -0,0 +1,251 @@
+/**
+ * Planning Game pipeline adapter.
+ * Subscribes to pipeline events and handles PG card lifecycle updates.
+ * Decouples PG logic from the orchestrator — works as an event-driven plugin.
+ *
+ * Handles:
+ * - Marking card as "In Progress" at session start
+ * - Decomposing tasks into subtasks after triage
+ * - Marking card as "To Validate" on approved completion
+ *
+ * If PG is disabled or no pgTaskId is present, the adapter does nothing.
+ */
+
+import { emitProgress, makeEvent } from "../utils/events.js";
+import { addCheckpoint } from "../session/store.js";
+import { appendPgCommits } from "../session/mutators.js";
+import { getLang } from "../utils/messages.js";
+
+/**
+ * Attach the PG adapter to a pipeline emitter.
+ * Call this once during runFlow() initialization.
+ *
+ * @param {object} opts
+ * @param {EventEmitter} opts.emitter - Pipeline event emitter
+ * @param {object} opts.session - Session object (mutated during pipeline)
+ * @param {object} opts.config - Resolved config
+ * @param {object} opts.logger - Logger instance
+ * @param {string|null} opts.pgTaskId - Planning Game card ID (e.g. "KJC-TSK-0099")
+ * @param {string|null} opts.pgProject - Planning Game project ID
+ * @returns {{ pgCard: object|null }} The fetched PG card (or null)
+ */
+export async function initPgAdapter({ session: _session, config, logger, pgTaskId, pgProject }) {
+  if (!pgTaskId || !pgProject || config.planning_game?.enabled === false) {
+    return { pgCard: null };
+  }
+
+  const pgCard = await markPgCardInProgress({ pgTaskId, pgProject, config, logger });
+  return { pgCard };
+}
+
+/**
+ * Handle PG task decomposition after triage.
+ * Creates subtask cards in PG when triage recommends decomposition.
+ */
+async function handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger }) {
+  const shouldDecompose = triageResult.stageResult?.shouldDecompose
+    && triageResult.stageResult.subtasks?.length > 1
+    && pgTaskId
+    && pgProject
+    && config.planning_game?.enabled !== false
+    && askQuestion;
+
+  if (!shouldDecompose) return;
+
+  try {
+    const { buildDecompositionQuestion, createDecompositionSubtasks } = await import("./decomposition.js");
+    const { createCard, relateCards, fetchCard } = await import("./client.js");
+
+    const lang = getLang(config);
+    const question = buildDecompositionQuestion(triageResult.stageResult.subtasks, pgTaskId, lang);
+    const answer = await askQuestion(question);
+
+    const normalizedAnswer = (answer || "").trim().toLowerCase();
+    const isAccept = normalizedAnswer === "1" || normalizedAnswer === "yes" || normalizedAnswer === "sí" || normalizedAnswer === "si";
+    if (isAccept) {
+      const parentCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId }).catch(() => null);
+      const createdSubtasks = await createDecompositionSubtasks({
+        client: { createCard, relateCards },
+        projectId: pgProject,
+        parentCardId: pgTaskId,
+        parentFirebaseId: parentCard?.firebaseId || null,
+        subtasks: triageResult.stageResult.subtasks,
+        epic: parentCard?.epic || null,
+        sprint: parentCard?.sprint || null,
+        codeveloper: config.planning_game?.codeveloper || null
+      });
+
+      stageResults.triage.pgSubtasks = createdSubtasks;
+      logger.info(`Planning Game: created ${createdSubtasks.length} subtasks from decomposition`);
+
+      emitProgress(
+        emitter,
+        makeEvent("pg:decompose", { ...eventBase, stage: "triage" }, {
+          message: `Created ${createdSubtasks.length} subtasks in Planning Game`,
+          detail: { subtasks: createdSubtasks.map((s) => ({ cardId: s.cardId, title: s.title })) }
+        })
+      );
+
+      await addCheckpoint(session, {
+        stage: "pg-decompose",
+        subtasksCreated: createdSubtasks.length,
+        cardIds: createdSubtasks.map((s) => s.cardId)
+      });
+    }
+  } catch (err) {
+    logger.warn(`Planning Game decomposition failed: ${err.message}`);
+  }
+}
+
+/**
+ * Mark PG card as "To Validate" on approved session completion.
+ * Merges commits from gitResult and session.pg_commits (accumulated during pipeline).
+ */
+export async function markPgCardToValidate({ pgCard, pgProject, config, session, gitResult, logger }) {
+  if (!pgCard || !pgProject) return;
+
+  try {
+    const { updateCard } = await import("./client.js");
+    const { buildCompletionUpdates } = await import("./adapter.js");
+
+    // Merge commits: session.pg_commits (accumulated) + gitResult.commits (final)
+    const accumulatedCommits = session.pg_commits || [];
+    const finalCommits = gitResult?.commits || [];
+    const seenHashes = new Set(accumulatedCommits.map(c => c.hash));
+    const mergedCommits = [...accumulatedCommits];
+    for (const c of finalCommits) {
+      if (!seenHashes.has(c.hash)) {
+        mergedCommits.push(c);
+      }
+    }
+
+    const pgUpdates = buildCompletionUpdates({
+      approved: true,
+      commits: mergedCommits,
+      startDate: session.pg_card?.startDate || session.created_at,
+      codeveloper: config.planning_game?.codeveloper || null
+    });
+    await updateCard({
+      projectId: pgProject,
+      cardId: session.pg_task_id,
+      firebaseId: pgCard.firebaseId,
+      updates: pgUpdates
+    });
+    logger.info(`Planning Game: ${session.pg_task_id} → To Validate`);
+  } catch (err) {
+    logger.warn(`Planning Game: could not update ${session.pg_task_id} on completion: ${err.message}`);
+  }
+}
+
+/**
+ * Convert a PG card's structured data into HU stories for the hu-reviewer stage.
+ * Returns an array of story objects ({id, text}) or null if the card lacks structured data.
+ *
+ * @param {object} pgCard - The PG card object (from fetchCard)
+ * @returns {Array<{id: string, text: string}>|null}
+ */
+export function buildHuStoriesFromPgCard(pgCard) {
+  if (!pgCard?.descriptionStructured?.length) return null;
+
+  const parts = [];
+
+  // User stories (Como/Quiero/Para → As/I want/So that)
+  for (const s of pgCard.descriptionStructured) {
+    parts.push(`As ${s.role}, I want ${s.goal}, so that ${s.benefit}.`);
+  }
+
+  // Acceptance criteria
+  if (pgCard.acceptanceCriteriaStructured?.length) {
+    parts.push("", "Acceptance Criteria:");
+    for (const ac of pgCard.acceptanceCriteriaStructured) {
+      if (ac.given && ac.when && ac.then) {
+        parts.push(`- Given ${ac.given}, When ${ac.when}, Then ${ac.then}`);
+      } else if (ac.raw) {
+        parts.push(`- ${ac.raw}`);
+      }
+    }
+  } else if (pgCard.acceptanceCriteria) {
+    parts.push("", "Acceptance Criteria:", pgCard.acceptanceCriteria);
+  }
+
+  const storyId = pgCard.cardId || "HU-PG-001";
+  const storyText = parts.join("\n");
+
+  return [{ id: storyId, text: storyText }];
+}
+
+/**
+ * Accumulate a commit into the session's pg_commits array.
+ * Called after each successful commitAll during the iteration loop.
+ * Best-effort: never throws.
+ *
+ * @param {object} session - Pipeline session (mutated)
+ * @param {{ hash: string, message: string, date?: string, author?: string }} commitInfo
+ */
+export function accumulateCommit(session, commitInfo) {
+  if (!session || !commitInfo?.hash) return;
+  appendPgCommits(session, [{
+    hash: commitInfo.hash,
+    message: commitInfo.message || "",
+    date: commitInfo.date || new Date().toISOString(),
+    author: commitInfo.author || "Karajan"
+  }]);
+}
+
+// --- Internal helpers ---
+
+async function markPgCardInProgress({ pgTaskId, pgProject, config, logger }) {
+  try {
+    const { fetchCard, updateCard } = await import("./client.js");
+    const pgCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId });
+    if (pgCard && pgCard.status !== "In Progress") {
+      await updateCard({
+        projectId: pgProject,
+        cardId: pgTaskId,
+        firebaseId: pgCard.firebaseId,
+        updates: {
+          status: "In Progress",
+          startDate: new Date().toISOString(),
+          developer: "dev_016",
+          codeveloper: config.planning_game?.codeveloper || null
+        }
+      });
+      logger.info(`Planning Game: ${pgTaskId} → In Progress`);
+    }
+    return pgCard;
+  } catch (err) {
+    logger.warn(`Planning Game: could not update ${pgTaskId}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * TSK-0339: integration adapter shape — the orchestrator consumes tracker
+ * hooks via this neutral interface, not via direct imports. `registerPgAdapter`
+ * is called once at bootstrap when `config.planning_game.enabled` is true,
+ * wiring these hooks into `src/orchestrator/integrations.js` under the
+ * "tracker" slot.
+ *
+ * Adding a new tracker (GitHub Projects, Jira, Linear, …) means creating
+ * a sibling `src/adapters/<name>/adapter.js` with the same hook surface,
+ * nothing else in the orchestrator changes.
+ */
+export const planningGameAdapter = {
+  name: "planning-game",
+  async onSessionStart(opts) { return initPgAdapter(opts); },
+  onCommit(session, commit) { accumulateCommit(session, commit); },
+  async onSessionApproved(opts) { return markPgCardToValidate(opts); },
+  buildHuStoriesFromCard(card) { return buildHuStoriesFromPgCard(card); },
+  async handleDecomposition(opts) { return handlePgDecomposition(opts); },
+  async createAdrsFromTradeoffs({ tradeoffs, pgTaskId, pgProject, taskTitle }) {
+    // Lazy-loaded to avoid pulling createArchitectADRs into every import.
+    const { createArchitectADRs } = await import("./architect-adrs.js");
+    const pgClient = await import("./client.js");
+    return createArchitectADRs({ tradeoffs, pgTaskId, pgProject, taskTitle, mcpClient: pgClient });
+  },
+};
+
+export async function registerPgAdapter() {
+  const { registerIntegration } = await import("../orchestrator/integrations.js");
+  registerIntegration("tracker", planningGameAdapter);
+}

package/src/plugins/loader.js

@@ -0,0 +1,67 @@
+/**
+ * Plugin loader: discovers and loads plugins from .karajan/plugins/ directories.
+ *
+ * Plugins are JS files that export a `register(api)` function.
+ * The `api` object provides: registerAgent, registerModel.
+ *
+ * Discovery order (all are loaded, not first-wins):
+ *   1. <project>/.karajan/plugins/*.js
+ *   2. ~/.karajan/plugins/*.js
+ */
+
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { getKarajanHome } from "../utils/paths.js";
+import { registerAgent } from "../agents/index.js";
+
+async function listPluginFiles(dir) {
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && e.name.endsWith(".js"))
+      .map((e) => path.join(dir, e.name));
+  } catch { /* plugin dir does not exist */
+    return [];
+  }
+}
+
+async function loadPlugin(filePath, api, logger) {
+  try {
+    const mod = await import(pathToFileURL(filePath).href);
+    const registerFn = mod.register || mod.default?.register;
+    if (typeof registerFn !== "function") {
+      logger?.warn?.(`Plugin ${filePath}: no register() export found, skipping`);
+      return null;
+    }
+    const meta = registerFn(api);
+    const name = meta?.name || path.basename(filePath, ".js");
+    logger?.debug?.(`Plugin loaded: ${name} (${filePath})`);
+    return { name, path: filePath, meta };
+  } catch (error) {
+    logger?.warn?.(`Plugin ${filePath} failed to load: ${error.message}`);
+    return null;
+  }
+}
+
+export async function loadPlugins({ projectDir, logger } = {}) {
+  const dirs = [];
+
+  if (projectDir) {
+    dirs.push(path.join(projectDir, ".karajan", "plugins"));
+  }
+  dirs.push(path.join(getKarajanHome(), "plugins"));
+
+  const api = { registerAgent };
+
+  const loaded = [];
+  for (const dir of dirs) {
+    const files = await listPluginFiles(dir);
+    for (const file of files) {
+      const result = await loadPlugin(file, api, logger);
+      if (result) loaded.push(result);
+    }
+  }
+
+  return loaded;
+}