@jskit-ai/jskit-cli 0.2.92 → 0.2.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.92",
+  "version": "0.2.97",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,9 +20,9 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.91",
-    "@jskit-ai/kernel": "0.1.83",
-    "@jskit-ai/shell-web": "0.1.82",
+    "@jskit-ai/jskit-catalog": "0.1.92",
+    "@jskit-ai/kernel": "0.1.84",
+    "@jskit-ai/shell-web": "0.1.83",
     "@vue/compiler-sfc": "^3.5.29",
     "ts-morph": "^28.0.0"
   },

package/src/server/appBlueprint.js

@@ -1,20 +1,42 @@
-import { mkdir, readFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import {
-  PROMPT_DIRECTORY
-} from "./sessionRuntime/constants.js";
-import {
-  fileExists,
-  normalizeText,
-  readTextIfExists,
-  writeTextFile
-} from "./sessionRuntime/io.js";
-import {
-  renderTemplate
-} from "./sessionRuntime/promptRenderer.js";
+import { fileURLToPath } from "node:url";
 
 const APP_BLUEPRINT_RELATIVE_PATH = ".jskit/APP_BLUEPRINT.md";
 const APP_PROMPT_OVERRIDE_RELATIVE_ROOT = ".jskit/prompts";
+const APP_BLUEPRINT_PROMPT_DIRECTORY = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "prompts");
+
+function normalizeText(value) {
+  return String(value || "").trim();
+}
+
+async function fileExists(filePath) {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTextIfExists(filePath) {
+  if (!filePath || !(await fileExists(filePath))) {
+    return "";
+  }
+  return readFile(filePath, "utf8");
+}
+
+async function writeTextFile(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${String(value || "").replace(/\s*$/u, "")}\n`, "utf8");
+}
+
+function renderTemplate(source, values = {}) {
+  return String(source || "").replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/gu, (_match, key) => {
+    return String(values[key] ?? "");
+  });
+}
 
 function resolveAppBlueprintPaths(targetRoot = process.cwd()) {
   const normalizedTargetRoot = path.resolve(normalizeText(targetRoot) || process.cwd());
@@ -37,7 +59,7 @@ async function readAppPromptTemplate(paths, templateName) {
   if (await fileExists(overridePath)) {
     return readTextIfExists(overridePath);
   }
-  return readTextIfExists(path.join(PROMPT_DIRECTORY, normalizedName));
+  return readTextIfExists(path.join(APP_BLUEPRINT_PROMPT_DIRECTORY, normalizedName));
 }
 
 async function renderAppBlueprintPrompt({ targetRoot = process.cwd(), appBrief = "" } = {}) {
@@ -116,6 +138,7 @@ async function readTextInputFile(cwd, inputPath) {
 
 export {
   APP_BLUEPRINT_RELATIVE_PATH,
+  APP_BLUEPRINT_PROMPT_DIRECTORY,
   APP_PROMPT_OVERRIDE_RELATIVE_ROOT,
   extractAppBlueprintText,
   readAppBlueprint,

package/src/server/core/argParser.js

@@ -23,8 +23,6 @@ function parseArgs(argv, { createCliError } = {}) {
         verbose: false,
         json: false,
         all: false,
-        abandoned: false,
-        completed: false,
         concrete: false,
         help: true,
         inlineOptions: {}
@@ -52,8 +50,6 @@ function parseArgs(argv, { createCliError } = {}) {
     verbose: false,
     json: false,
     all: false,
-    abandoned: false,
-    completed: false,
     concrete: false,
     help: false,
     inlineOptions: {}
@@ -113,14 +109,6 @@ function parseArgs(argv, { createCliError } = {}) {
       options.all = true;
       continue;
     }
-    if (token === "--abandoned") {
-      options.abandoned = true;
-      continue;
-    }
-    if (token === "--completed") {
-      options.completed = true;
-      continue;
-    }
     if (token === "--concrete") {
       options.concrete = true;
       continue;

package/src/server/core/commandCatalog.js

@@ -9,9 +9,7 @@ const OPTION_FLAG_LABELS = Object.freeze({
   checkDiLabels: "--check-di-labels",
   verbose: "--verbose",
   json: "--json",
-  all: "--all",
-  abandoned: "--abandoned",
-  completed: "--completed"
+  all: "--all"
 });
 
 const PARSED_BOOLEAN_OPTION_KEYS = Object.freeze(Object.keys(OPTION_FLAG_LABELS));
@@ -200,94 +198,6 @@ const COMMAND_DESCRIPTORS = Object.freeze({
     allowedValueOptionNames: Object.freeze([]),
     canDelegateInlineOptions: (positional = []) => Array.isArray(positional) && positional.length > 0
   }),
-  session: Object.freeze({
-    command: "session",
-    aliases: Object.freeze([]),
-    showInOverview: true,
-    summary: "Run file-backed JSKIT issue sessions.",
-    minimalUse: "jskit session create",
-    parameters: Object.freeze([
-      Object.freeze({
-        name: "create | <sessionId>",
-        description: "Create a session, inspect a session, or run a session subcommand."
-      }),
-      Object.freeze({
-        name: "[step|create_worktree|run_npm_install|define_issue|create_issue_file|create_issue_on_gh|make_plan|execute_plan|run_deep_ui_check|run_automated_checks|update_blueprint|commit_changes|create_pull_request_file|create_pr_on_gh|prepare_for_merge|merge_pr|sync_main_checkout|finish_session|next|skip|deslop|resolve-deslop|diff|rewind|abandon|adopt-codex-thread]",
-        description: "Inspect, run an explicit step command, continue, skip, deslop, inspect a diff, rewind, abandon, or attach a Codex thread id."
-      })
-    ]),
-    defaults: Object.freeze([
-      "Active session state lives in .jskit/sessions/active/<session_id> under the current target app.",
-      "Session worktrees live in .jskit/sessions/active/<session_id>/worktree.",
-      "The session id is timestamp-based and is the primary key.",
-      "Bare list output includes active sessions only; use --abandoned, --completed, or --all for archived sessions.",
-      "Use --json for the stable machine-readable contract consumed by JSKIT AI Studio.",
-      "Issue handoff is file-based: Codex writes issue.md under the session root, then the user runs next. Plans stay in the terminal.",
-      "Use step to inspect the current step without running its work.",
-      "Use explicit step commands such as create_worktree, run_npm_install, define_issue, create_issue_file, create_issue_on_gh, make_plan, execute_plan, run_deep_ui_check, run_automated_checks, update_blueprint, commit_changes, create_pull_request_file, create_pr_on_gh, prepare_for_merge, merge_pr, sync_main_checkout, and finish_session to do the current step's work.",
-      "Use next to move to the next step after the current step's required work/result exists.",
-      "Use skip to record the current step as skipped and move to the next step.",
-      "Use deslop to run the review/deslop prompt from either review/deslop step.",
-      "Use resolve-deslop to send the explicit resolve review/deslop prompt. Nothing advances automatically afterward.",
-      "Use rewind <step_id> or rewind --step <step_id> to delete a completed step and later JSKIT-owned session artifacts.",
-      "Use --rework-notes - with --user-check failed to stay on user check and decide where to rewind.",
-      "Use deslop instead of hand-writing --review-findings-remaining true.",
-      "Use next instead of hand-writing --review-findings-remaining false.",
-      "Use skip --skip-reason \"<reason>\" when a step is intentionally skipped.",
-      "Use prepare_for_merge at Merge PR to render the Codex prep prompt.",
-      "Use merge_pr at Merge PR to attempt the GitHub merge.",
-      "Use sync_main_checkout at Sync main checkout after a successful merge.",
-      "Use finish_session at Congratulations! to archive the completed session.",
-      "Run the blueprint step once to render its Codex prompt, then again after Codex updates .jskit/APP_BLUEPRINT.md."
-    ]),
-    examples: Object.freeze([
-      Object.freeze({
-        label: "Manual CLI flow",
-        lines: Object.freeze([
-          "jskit session create",
-          "jskit session 2026-05-11_21-42-08 step",
-          "jskit session 2026-05-11_21-42-08 create_worktree",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 run_npm_install",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 define_issue --prompt \"Fix the customer filters\"",
-          "jskit session 2026-05-11_21-42-08 skip --skip-reason \"Handled outside JSKIT\"",
-          "jskit session 2026-05-11_21-42-08 create_issue_file",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 create_issue_on_gh",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 make_plan",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 execute_plan",
-          "jskit session 2026-05-11_21-42-08 deslop",
-          "jskit session 2026-05-11_21-42-08 resolve-deslop",
-          "jskit session 2026-05-11_21-42-08 commit_changes",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 create_pull_request_file",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 create_pr_on_gh",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 prepare_for_merge",
-          "jskit session 2026-05-11_21-42-08 merge_pr",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 sync_main_checkout",
-          "jskit session 2026-05-11_21-42-08 next",
-          "jskit session 2026-05-11_21-42-08 finish_session",
-          "jskit session 2026-05-11_21-42-08 step --user-check failed --rework-notes -",
-          "jskit session 2026-05-11_21-42-08 rewind plan_made --json",
-          "jskit session 2026-05-11_21-42-08 diff --json"
-        ])
-      })
-    ]),
-    fullUse:
-      "jskit session [create|new|<sessionId>] [step|create_worktree|run_npm_install|define_issue|create_issue_file|create_issue_on_gh|make_plan|execute_plan|run_deep_ui_check|run_automated_checks|update_blueprint|commit_changes|create_pull_request_file|create_pr_on_gh|prepare_for_merge|merge_pr|sync_main_checkout|finish_session|next|skip|deslop|resolve-deslop|diff|rewind|abandon|adopt-codex-thread] [step_id] [--step <step_id>] [--prompt <text>] [--review-findings-remaining true|--review-findings-remaining false] [--resolve-deslop true] [--skip-step true|skip --skip-reason <text>] [--user-check <passed|failed>] [--rework-notes <text>|--rework-notes-file <path>] [--codex-thread-id <id>] [--abandoned|--completed|--all] [--json]",
-    showHelpOnBareInvocation: false,
-    handlerName: "commandSession",
-    allowedFlagKeys: Object.freeze(["json", "abandoned", "completed", "all"]),
-    inlineOptionMode: "delegate",
-    allowedValueOptionNames: Object.freeze([]),
-    canDelegateInlineOptions: (positional = []) => Array.isArray(positional) && positional.length > 0
-  }),
   blueprint: Object.freeze({
     command: "blueprint",
     aliases: Object.freeze([]),
@@ -301,7 +211,7 @@ const COMMAND_DESCRIPTORS = Object.freeze({
       })
     ]),
     defaults: Object.freeze([
-      "The app blueprint is product-level app state, not a feature-session step.",
+      "The app blueprint is product-level app state, not a feature delivery step.",
       "The saved blueprint lives at .jskit/APP_BLUEPRINT.md in the current target app.",
       "Project prompt overrides live at .jskit/prompts/app_blueprint.md.",
       "Use --json for a stable machine-readable response."

package/src/server/core/createCommandHandlers.js

@@ -6,7 +6,6 @@ import { createAppCommands } from "../commandHandlers/app.js";
 import { createMobileCommands } from "../commandHandlers/mobile.js";
 import { createHealthCommands } from "../commandHandlers/health.js";
 import { createCompletionCommands } from "../commandHandlers/completion.js";
-import { createSessionCommands } from "../commandHandlers/session.js";
 import { createBlueprintCommands } from "../commandHandlers/blueprint.js";
 import { createHelperMapCommands } from "../commandHandlers/helperMap.js";
 
@@ -32,7 +31,6 @@ function createCommandHandlers(deps = {}) {
   const { commandMobile } = createMobileCommands(commandContext, { commandAdd });
   const { commandDoctor, commandLintDescriptors } = createHealthCommands(commandContext);
   const { commandCompletion } = createCompletionCommands(commandContext);
-  const { commandSession } = createSessionCommands(commandContext);
   const { commandBlueprint } = createBlueprintCommands(commandContext);
   const { commandHelperMap } = createHelperMapCommands(commandContext);
 
@@ -53,7 +51,6 @@ function createCommandHandlers(deps = {}) {
     commandRemove,
     commandDoctor,
     commandLintDescriptors,
-    commandSession,
     commandBlueprint,
     commandHelperMap
   };

package/src/server/helperMap.js

@@ -1,3 +1,6 @@
+import {
+  createHash
+} from "node:crypto";
 import {
   mkdir,
   readFile,
@@ -17,10 +20,11 @@ const {
   ModuleKind,
   ModuleResolutionKind,
   Project,
-  ScriptTarget
+  ScriptTarget,
+  ts
 } = tsMorph;
 
-const HELPER_MAP_SCHEMA_VERSION = 1;
+const HELPER_MAP_SCHEMA_VERSION = 2;
 const CODE_EXTENSIONS = new Set([".cjs", ".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"]);
 const APP_SCAN_ROOTS = Object.freeze(["src", "packages", "config", "server", "scripts"]);
 const EXCLUDED_DIR_NAMES = new Set([
@@ -50,6 +54,12 @@ async function readJsonFile(filePath) {
   return JSON.parse(await readFile(filePath, "utf8"));
 }
 
+async function readFileHash(filePath) {
+  return createHash("sha256")
+    .update(await readFile(filePath))
+    .digest("hex");
+}
+
 function normalizePackageDependencies(packageJson = {}) {
   const dependencies = {
     ...(packageJson.dependencies || {}),
@@ -89,37 +99,6 @@ function createExportAnalysisProject() {
   });
 }
 
-function kindFromDeclaration(declaration, exportName = "") {
-  if (exportName === "default") {
-    return "default";
-  }
-  switch (declaration.getKindName()) {
-    case "ClassDeclaration":
-      return "class";
-    case "EnumDeclaration":
-      return "enum";
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-    case "MethodDeclaration":
-      return "function";
-    case "InterfaceDeclaration":
-      return "interface";
-    case "TypeAliasDeclaration":
-      return "type";
-    case "VariableDeclaration": {
-      const initializer = typeof declaration.getInitializer === "function"
-        ? declaration.getInitializer()
-        : null;
-      const initializerKind = initializer?.getKindName?.() || "";
-      return initializerKind === "ArrowFunction" || initializerKind === "FunctionExpression"
-        ? "function"
-        : "value";
-    }
-    default:
-      return "export";
-  }
-}
-
 function addSymbol(symbols, symbol) {
   if (!symbol.name) {
     return;
@@ -135,14 +114,116 @@ function addSymbol(symbols, symbol) {
   });
 }
 
+function compilerNodeHasModifier(node, modifierKind) {
+  return Array.isArray(node?.modifiers) && node.modifiers.some((modifier) => modifier.kind === modifierKind);
+}
+
+function exportedDeclarationName(node) {
+  if (compilerNodeHasModifier(node, ts.SyntaxKind.DefaultKeyword)) {
+    return "default";
+  }
+  return String(node?.name?.text || node?.name?.escapedText || "").trim();
+}
+
+function addExportedDeclarationSymbol(symbols, node, kind = "export") {
+  const name = exportedDeclarationName(node);
+  if (!name) {
+    return;
+  }
+  addSymbol(symbols, {
+    kind: name === "default" ? "default" : kind,
+    name
+  });
+}
+
+function bindingNameTexts(bindingName, names = []) {
+  if (!bindingName) {
+    return names;
+  }
+  if (ts.isIdentifier(bindingName)) {
+    names.push(String(bindingName.text || ""));
+    return names;
+  }
+  if (ts.isObjectBindingPattern(bindingName) || ts.isArrayBindingPattern(bindingName)) {
+    for (const element of bindingName.elements || []) {
+      if (element.name) {
+        bindingNameTexts(element.name, names);
+      }
+    }
+  }
+  return names;
+}
+
+function addVariableStatementExports(symbols, statement) {
+  if (!compilerNodeHasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+    return;
+  }
+  for (const declaration of statement.declarationList?.declarations || []) {
+    for (const name of bindingNameTexts(declaration.name)) {
+      addSymbol(symbols, {
+        kind: declaration.initializer &&
+          (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))
+          ? "function"
+          : "value",
+        name
+      });
+    }
+  }
+}
+
+function addNamedExportSymbols(symbols, exportClause) {
+  if (!exportClause) {
+    return;
+  }
+  if (ts.isNamespaceExport(exportClause)) {
+    addSymbol(symbols, {
+      kind: "export",
+      name: String(exportClause.name?.text || "")
+    });
+    return;
+  }
+  if (!ts.isNamedExports(exportClause)) {
+    return;
+  }
+  for (const specifier of exportClause.elements || []) {
+    addSymbol(symbols, {
+      kind: "export",
+      name: String(specifier.name?.text || "")
+    });
+  }
+}
+
 function extractExportedSymbols(sourceFile) {
   const symbols = new Map();
-  for (const [name, declarations] of sourceFile.getExportedDeclarations()) {
-    for (const declaration of declarations) {
+  for (const statement of sourceFile.compilerNode.statements || []) {
+    if (ts.isExportDeclaration(statement)) {
+      addNamedExportSymbols(symbols, statement.exportClause);
+      continue;
+    }
+    if (ts.isExportAssignment(statement)) {
       addSymbol(symbols, {
-        name,
-        kind: kindFromDeclaration(declaration, name)
+        kind: "default",
+        name: "default"
       });
+      continue;
+    }
+    if (ts.isVariableStatement(statement)) {
+      addVariableStatementExports(symbols, statement);
+      continue;
+    }
+    if (!compilerNodeHasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+      continue;
+    }
+    if (ts.isFunctionDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "function");
+    } else if (ts.isClassDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "class");
+    } else if (ts.isInterfaceDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "interface");
+    } else if (ts.isTypeAliasDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "type");
+    } else if (ts.isEnumDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "enum");
     }
   }
 
@@ -277,11 +358,75 @@ function flattenPackageExports(exportsField) {
   });
 }
 
-async function collectJskitPackageExports(targetRoot, packageJson = {}) {
+async function packageExportTargetRecords(packageRoot, exportTargets = []) {
+  const records = [];
+  for (const exportTarget of exportTargets) {
+    const normalizedTarget = exportTarget.target.replace(/^\.\//u, "");
+    const targetPath = path.join(packageRoot, normalizedTarget);
+    const ext = path.extname(targetPath);
+    if (!CODE_EXTENSIONS.has(ext) || !await pathExists(targetPath)) {
+      continue;
+    }
+    records.push({
+      absolutePath: targetPath,
+      hash: await readFileHash(targetPath),
+      subpath: exportTarget.subpath,
+      target: normalizedTarget.split(path.sep).join("/")
+    });
+  }
+  return records;
+}
+
+function packageExportFingerprint({
+  installedPackageJson = {},
+  packageName = "",
+  targetRecords = []
+} = {}) {
+  return createHash("sha256")
+    .update(JSON.stringify({
+      name: packageName,
+      version: installedPackageJson.version || "",
+      targets: targetRecords.map((record) => ({
+        hash: record.hash,
+        subpath: record.subpath,
+        target: record.target
+      }))
+    }))
+    .digest("hex");
+}
+
+function cachedPackageExports(previousPackagesByName = new Map(), packageName = "", fingerprint = "") {
+  const previous = previousPackagesByName.get(packageName);
+  if (
+    !previous ||
+    previous.installed !== true ||
+    previous.fingerprint !== fingerprint ||
+    !Array.isArray(previous.exports)
+  ) {
+    return null;
+  }
+  return {
+    name: previous.name,
+    version: previous.version || "",
+    fingerprint: previous.fingerprint,
+    installed: true,
+    exports: previous.exports
+  };
+}
+
+function previousPackageMap(previousMap = null) {
+  return new Map(
+    (Array.isArray(previousMap?.jskitPackages) ? previousMap.jskitPackages : [])
+      .map((packageEntry) => [packageEntry.name, packageEntry])
+      .filter(([name]) => name)
+  );
+}
+
+async function collectJskitPackageExports(targetRoot, packageJson = {}, previousMap = null) {
   const packageNames = normalizePackageDependencies(packageJson)
     .filter((name) => name.startsWith("@jskit-ai/"));
   const packages = [];
-  const project = createExportAnalysisProject();
+  const previousPackagesByName = previousPackageMap(previousMap);
 
   for (const packageName of packageNames) {
     const packageRoot = path.join(targetRoot, "node_modules", ...packageName.split("/"));
@@ -297,21 +442,28 @@ async function collectJskitPackageExports(targetRoot, packageJson = {}) {
 
     const installedPackageJson = await readJsonFile(packageJsonPath);
     const exportTargets = flattenPackageExports(installedPackageJson.exports || {});
+    const targetRecords = await packageExportTargetRecords(packageRoot, exportTargets);
+    const fingerprint = packageExportFingerprint({
+      installedPackageJson,
+      packageName,
+      targetRecords
+    });
+    const cachedEntry = cachedPackageExports(previousPackagesByName, packageName, fingerprint);
+    if (cachedEntry) {
+      packages.push(cachedEntry);
+      continue;
+    }
+
+    const project = createExportAnalysisProject();
     const exports = [];
-    for (const exportTarget of exportTargets) {
-      const normalizedTarget = exportTarget.target.replace(/^\.\//u, "");
-      const targetPath = path.join(packageRoot, normalizedTarget);
-      const ext = path.extname(targetPath);
-      if (!CODE_EXTENSIONS.has(ext) || !await pathExists(targetPath)) {
-        continue;
-      }
+    for (const targetRecord of targetRecords) {
       const sourceFile = await addCodeFileToProject(project, {
-        absolutePath: targetPath,
-        relativePath: normalizedTarget
+        absolutePath: targetRecord.absolutePath,
+        relativePath: targetRecord.target
       });
       exports.push({
-        subpath: exportTarget.subpath,
-        target: normalizedTarget.split(path.sep).join("/"),
+        subpath: targetRecord.subpath,
+        target: targetRecord.target,
         exports: sourceFile ? extractExportedSymbols(sourceFile) : []
       });
     }
@@ -319,6 +471,7 @@ async function collectJskitPackageExports(targetRoot, packageJson = {}) {
     packages.push({
       name: packageName,
       version: installedPackageJson.version || "",
+      fingerprint,
       installed: true,
       exports
     });
@@ -383,7 +536,7 @@ function renderHelperMapMarkdown(map) {
   return `${lines.join("\n").replace(/\n{3,}/gu, "\n\n").trimEnd()}\n`;
 }
 
-async function buildHelperMap({ targetRoot }) {
+async function buildHelperMap({ targetRoot, previousMap = null }) {
   const packageJsonPath = path.join(targetRoot, "package.json");
   const packageJson = await readJsonFile(packageJsonPath);
   const map = {
@@ -396,7 +549,7 @@ async function buildHelperMap({ targetRoot }) {
     app: {
       files: await collectAppExports(targetRoot)
     },
-    jskitPackages: await collectJskitPackageExports(targetRoot, packageJson)
+    jskitPackages: await collectJskitPackageExports(targetRoot, packageJson, previousMap)
   };
   return {
     ok: true,
@@ -430,12 +583,17 @@ async function readHelperMap({ targetRoot }) {
 }
 
 async function updateHelperMap({ targetRoot }) {
-  const payload = await buildHelperMap({ targetRoot });
+  const helperMapJsonPath = path.join(targetRoot, HELPER_MAP_JSON_RELATIVE_PATH);
+  const currentJson = await pathExists(helperMapJsonPath)
+    ? await readFile(helperMapJsonPath, "utf8")
+    : "";
+  const previousMap = currentJson ? JSON.parse(currentJson) : null;
+  const payload = await buildHelperMap({
+    previousMap,
+    targetRoot
+  });
   const markdown = renderHelperMapMarkdown(payload.map);
   const json = `${JSON.stringify(payload.map, null, 2)}\n`;
-  const currentJson = await pathExists(payload.helperMapJsonPath)
-    ? await readFile(payload.helperMapJsonPath, "utf8")
-    : "";
   const currentMarkdown = await pathExists(payload.helperMapMarkdownPath)
     ? await readFile(payload.helperMapMarkdownPath, "utf8")
     : "";

package/src/server/index.js

@@ -1,3 +1,2 @@
 export { runCli } from "./core/createCliRunner.js";
-export * from "./sessionRuntime.js";
 export * from "./appBlueprint.js";

package/src/server/{sessionRuntime/prompts → prompts}/app_blueprint.md

@@ -4,7 +4,7 @@ App brief:
 
 {{app_brief}}
 
-Produce a concise but useful app-level blueprint. It must describe product intent, platform choices, and architectural boundaries. It must not become an implementation workboard for one issue.
+Produce a concise but useful app-level blueprint. It must describe product intent, platform choices, and architectural boundaries. It must not become an implementation task list for one issue.
 
 Before writing the blueprint, classify the app state if local files are available: