@pourkit/cli 0.0.0-next-20260624074234 → 0.0.0-next-20260625073725

package/dist/cli.js

@@ -10634,9 +10634,9 @@ Recall before substantial work: before starting non-trivial planning or implemen
 
 Capture durable knowledge: store concise reusable observations when a durable resolved error, design decision, user preference, significant outcome, or long-session progress summary is discovered. Do not store trivial details, raw logs, transcripts, tool output, git status, prompt dumps, secrets, or ephemeral state.
 
-Database path: use \`$POURKIT_ICM_DB\` when set, otherwise use \`.pourkit/icm/memories.db\`. The Pourkit Memory Store is repo-scoped; do not use a global ICM database or topic naming as the isolation boundary.
+Database path: host CLI commands must pass \`--db .pourkit/icm/memories.db\` from the repository root. Pourkit-launched Docker runs set \`$POURKIT_ICM_DB\` to the mounted container DB path for runtime plumbing. The Pourkit Memory Store is repo-scoped; do not use a global ICM database or topic naming as the isolation boundary.
 
-CLI fallback: when MCP memory tools are unavailable, recall with \`icm --db "$POURKIT_ICM_DB" recall "<query>"\` or \`icm --db .pourkit/icm/memories.db recall "<query>"\`, and store durable observations with \`icm --db "$POURKIT_ICM_DB" store -c "<concise reusable observation>"\` or \`icm --db .pourkit/icm/memories.db store -c "<concise reusable observation>"\`.
+CLI fallback: when MCP memory tools are unavailable, recall with \`icm --db .pourkit/icm/memories.db recall "<query>"\`, and store durable observations with \`icm --db .pourkit/icm/memories.db store -c "<concise reusable observation>"\`.
 
 Memory is advisory only. Never treat memory as a replacement for reading current repository files, Run Context, artifacts, or verification output. When memory conflicts with current source or canonical state, current source and canonical state win.
 
@@ -10648,17 +10648,17 @@ You MUST use it actively. Not optional.
 
 ### Recall (before starting work)
 \`\`\`bash
-icm recall "query"                        # search memories
-icm recall "query" -t "topic-name"        # filter by topic
-icm recall-context "query" --limit 5      # formatted for prompt injection
+icm --db .pourkit/icm/memories.db recall "query"                        # search memories
+icm --db .pourkit/icm/memories.db recall "query" -t "topic-name"        # filter by topic
+icm --db .pourkit/icm/memories.db recall-context "query" --limit 5      # formatted for prompt injection
 \`\`\`
 
 ### Store \u2014 MANDATORY triggers
-You MUST call \`icm store\` when ANY of the following happens:
-1. **Error resolved** \u2192 \`icm store -t errors-resolved -c "description" -i high -k "keyword1,keyword2"\`
-2. **Architecture/design decision** \u2192 \`icm store -t decisions-{project} -c "description" -i high\`
-3. **User preference discovered** \u2192 \`icm store -t preferences -c "description" -i critical\`
-4. **Significant task completed** \u2192 \`icm store -t context-{project} -c "summary of work done" -i high\`
+You MUST call \`icm --db .pourkit/icm/memories.db store\` when ANY of the following happens:
+1. **Error resolved** \u2192 \`icm --db .pourkit/icm/memories.db store -t errors-resolved -c "description" -i high -k "keyword1,keyword2"\`
+2. **Architecture/design decision** \u2192 \`icm --db .pourkit/icm/memories.db store -t decisions-{project} -c "description" -i high\`
+3. **User preference discovered** \u2192 \`icm --db .pourkit/icm/memories.db store -t preferences -c "description" -i critical\`
+4. **Significant task completed** \u2192 \`icm --db .pourkit/icm/memories.db store -t context-{project} -c "summary of work done" -i high\`
 5. **Conversation exceeds ~20 tool calls without a store** \u2192 store a progress summary
 
 Do this BEFORE responding to the user. Not after. Not later. Immediately.
@@ -10667,9 +10667,9 @@ Do NOT store: trivial details, info already in CLAUDE.md, ephemeral state (build
 
 ### Other commands
 \`\`\`bash
-icm update <id> -c "updated content"     # edit memory in-place
-icm health                                # topic hygiene audit
-icm topics                                # list all topics
+icm --db .pourkit/icm/memories.db update <id> -c "updated content"     # edit memory in-place
+icm --db .pourkit/icm/memories.db health                                # topic hygiene audit
+icm --db .pourkit/icm/memories.db topics                                # list all topics
 \`\`\`
 <!-- icm:end -->`;
 }
@@ -12837,9 +12837,13 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 
 // commands/memory-init.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
+import { execFile as execFile3 } from "child_process";
 import { join as join17 } from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
+  const execCommand = options.execCommand ?? execFileAsync3;
   const configPath = join17(cwd, ".pourkit", "config.json");
   if (!existsSync17(configPath)) {
     return {
@@ -12872,7 +12876,21 @@ async function runMemoryInitCommand(options) {
     const next = { ...raw, memory };
     writeFileSync5(configPath, JSON.stringify(next, null, 2) + "\n");
   }
-  mkdirSync8(join17(cwd, ".pourkit", "icm"), { recursive: true });
+  const memoryDir = join17(cwd, ".pourkit", "icm");
+  const memoryDbPath = join17(memoryDir, "memories.db");
+  mkdirSync8(memoryDir, { recursive: true });
+  let dbInitialized = false;
+  let warning;
+  try {
+    await execCommand(
+      "icm",
+      ["--db", memoryDbPath, "recall", "pourkit memory init smoke"],
+      { cwd }
+    );
+    dbInitialized = true;
+  } catch {
+    warning = "ICM is not available or could not initialize .pourkit/icm/memories.db. Install ICM and run `pourkit doctor` to verify repo-scoped memory setup.";
+  }
   const gitignorePath = join17(cwd, ".gitignore");
   updateManagedBlockSync(gitignorePath, generateGitignoreBlock());
   const managed = await generateManagedAgentInstructions({
@@ -12893,7 +12911,9 @@ async function runMemoryInitCommand(options) {
   return {
     ok: true,
     alreadyEnabled,
-    message: alreadyEnabled ? "Memory is already enabled. Refreshed repo-scoped memory setup." : "Memory enabled. Run `pourkit doctor` to verify setup."
+    dbInitialized,
+    warning,
+    message: `${alreadyEnabled ? "Memory is already enabled. Refreshed repo-scoped memory setup." : "Memory enabled. Run `pourkit doctor` to verify setup."}${warning ? ` ${warning}` : ""}`
   };
 }
 function updateManagedBlockSync(filePath, content) {
@@ -13074,9 +13094,14 @@ function localSchemaDir(repoRoot2) {
   return resolve3(repoRoot2, ".pourkit/schema");
 }
 var MANAGED_BLOCK_BEGIN2 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
+var MANAGED_BLOCK_BEGIN_MARKER = MANAGED_BLOCK_BEGIN2.trim();
+var MANAGED_BLOCK_END_MARKER = "<!-- END POURKIT MANAGED BLOCK -->";
 var OLD_DOCS_PATH_PATTERN = ".pourkit/docs/agents/";
 function resolvePackagedManagedPath(...segments) {
-  return resolve3(__dirname3, "..", "managed", ...segments);
+  const bundledPath = resolve3(__dirname3, "managed", ...segments);
+  const sourcePath = resolve3(__dirname3, "..", "managed", ...segments);
+  const candidates = [bundledPath, sourcePath];
+  return candidates.find((candidate) => existsSync18(candidate)) ?? bundledPath;
 }
 function resolvePackagedManagedDocPath(docName) {
   return resolvePackagedManagedPath("docs", "agents", docName);
@@ -13631,21 +13656,53 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     ok: hasGitignoreEntry,
     detail: hasGitignoreEntry ? ".gitignore covers .pourkit/icm/" : ".gitignore does not cover .pourkit/icm/"
   });
+  const memoryDbPath = resolve3(cwd, ".pourkit", "icm", "memories.db");
+  const hasMemoryDb = existsSync18(memoryDbPath);
+  checks.push({
+    name: "icm-db-exists",
+    ok: hasMemoryDb,
+    detail: hasMemoryDb ? ".pourkit/icm/memories.db exists" : ".pourkit/icm/memories.db is missing"
+  });
   const shapeValid = memoryConfig.enabled === true && memoryConfig.provider === "icm";
   checks.push({
     name: "config-memory-shape",
     ok: shapeValid,
     detail: shapeValid ? "memory: { enabled: true, provider: icm }" : `invalid memory config: enabled=${memoryConfig.enabled}, provider=${memoryConfig.provider}`
   });
+  const staleAgentFiles = ["AGENTS.md", "CLAUDE.md"].filter((fileName) => {
+    const filePath = resolve3(cwd, fileName);
+    if (!existsSync18(filePath)) return false;
+    const content = readFileSync18(filePath, "utf-8");
+    const managedBlock = extractManagedBlockContent(content);
+    return managedBlock !== null && hasBareIcmMemoryCommand(managedBlock);
+  });
+  checks.push({
+    name: "agent-memory-instructions",
+    ok: staleAgentFiles.length === 0,
+    detail: staleAgentFiles.length === 0 ? "managed agent memory instructions avoid bare ICM commands" : `stale bare ICM commands found in ${staleAgentFiles.join(", ")}`
+  });
   checks.push({
     name: "docker-image-advisory",
     ok: true,
     detail: "advisory only"
   });
   const ok = checks.filter((c) => c.name !== "docker-image-advisory").every((c) => c.ok);
-  const recommendation = ok ? null : "Run `pourkit memory init` to repair ICM memory setup, install ICM on PATH for host planning, or rebuild the sandbox image for Docker runs.";
+  const recommendation = ok ? null : "Run `pourkit memory init` or `pourkit sync workflow-pack` to repair ICM memory setup, install ICM on PATH for host planning, or rebuild the sandbox image for Docker runs.";
   return { ok, enabled: true, checks, recommendation };
 }
+function hasBareIcmMemoryCommand(content) {
+  return /(^|\n)\s*icm\s+(recall|recall-context|store|update|health|topics)\b/.test(
+    content
+  ) || /`icm\s+(recall|recall-context|store|update|health|topics)\b/.test(content);
+}
+function extractManagedBlockContent(content) {
+  const beginIdx = content.indexOf(MANAGED_BLOCK_BEGIN_MARKER);
+  if (beginIdx === -1) return null;
+  const contentStart = beginIdx + MANAGED_BLOCK_BEGIN_MARKER.length;
+  const endIdx = content.indexOf(MANAGED_BLOCK_END_MARKER, contentStart);
+  if (endIdx === -1) return null;
+  return content.slice(contentStart, endIdx);
+}
 async function runDoctorCommand(options) {
   const repoRootPath = options.cwd ?? process.cwd();
   const schemaDir = localSchemaDir(repoRootPath);
@@ -13800,8 +13857,10 @@ var OVERRIDES_DIR = ".pourkit/overrides";
 var MANAGED_BLOCK_BEGIN3 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
 var MANAGED_BLOCK_END2 = "\n<!-- END POURKIT MANAGED BLOCK -->";
 function resolvePackagedManagedPath2(...segments) {
-  const candidates = [resolve4(__dirname4, "..", "managed", ...segments)];
-  return candidates[0];
+  const bundledPath = resolve4(__dirname4, "managed", ...segments);
+  const sourcePath = resolve4(__dirname4, "..", "managed", ...segments);
+  const candidates = [bundledPath, sourcePath];
+  return candidates.find((candidate) => existsSync19(candidate)) ?? bundledPath;
 }
 function resolvePackagedManagedDocPath2(docName) {
   return resolvePackagedManagedPath2("docs", "agents", docName);
@@ -16074,11 +16133,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260624074234")) {
-    return "0.0.0-next-20260624074234";
+  if (isPackageVersion("0.0.0-next-20260625073725")) {
+    return "0.0.0-next-20260625073725";
   }
-  if (isReleaseVersion("0.0.0-next-20260624074234")) {
-    return "0.0.0-next-20260624074234";
+  if (isReleaseVersion("0.0.0-next-20260625073725")) {
+    return "0.0.0-next-20260625073725";
   }
   try {
     const root = repoRoot();