snipara-companion 3.0.3 → 3.0.4

package/dist/index.d.ts

@@ -1971,6 +1971,7 @@ interface MemoryAuditResult {
     version: "snipara.memory_audit.v1";
     generatedAt: string;
     scope?: MemoryScope;
+    summary?: MemoryAuditSummary;
     health?: Record<string, unknown>;
     cleanCandidates?: Record<string, unknown>;
     compactDryRun?: Record<string, unknown>;
@@ -1979,6 +1980,16 @@ interface MemoryAuditResult {
         message: string;
     }>;
 }
+interface MemoryAuditSummary {
+    totalScanned?: number;
+    activeCount?: number;
+    autoCompactThreshold?: number;
+    autoCompactWouldTrigger?: boolean;
+    cleanupCandidateCounts: Record<string, number>;
+    compactDryRunMutated?: boolean;
+    compactDryRunPlannedActions?: number;
+    recommendedActions: string[];
+}
 declare function memoryHealthCommand(options: MemoryHealthCommandOptions): Promise<void>;
 declare function memoryCleanCandidatesCommand(options: MemoryCleanCandidatesCommandOptions): Promise<void>;
 declare function memoryCompactCommand(options: MemoryCompactCommandOptions): Promise<void>;
@@ -2407,6 +2418,7 @@ interface TeamSyncSummary {
     handoffCount: number;
     files: string[];
     staleWorkExplanation: TeamSyncStaleWorkExplanation;
+    hygieneActions: TeamSyncHygieneAction[];
     latestActiveWork?: TeamSyncWorkRecord;
     latestStaleWork?: TeamSyncWorkRecord;
     latestCompletedWork?: TeamSyncWorkRecord;
@@ -2423,6 +2435,12 @@ interface TeamSyncStaleWorkExplanation {
     latestStaleWorkAgeHours?: number;
     message: string;
 }
+interface TeamSyncHygieneAction {
+    kind: "sweep-preview" | "sweep-archive" | "complete-work" | "handoff";
+    command: string;
+    reason: string;
+    mutates: boolean;
+}
 interface TeamSyncCommandOptions {
     id?: string;
     summary?: string;

package/dist/index.js

@@ -8826,6 +8826,16 @@ function isRecord2(value) {
 function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function numberLikeValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
 function preview(value, maxLength = 180) {
   const text = typeof value === "string" ? value : value === void 0 || value === null ? "" : JSON.stringify(value);
   return text.length > maxLength ? `${text.slice(0, maxLength - 1)}...` : text;
@@ -8989,6 +8999,78 @@ function printCompactDryRun(result) {
     }
   }
 }
+function buildMemoryAuditSummary(audit) {
+  const health = isRecord2(audit.health) ? audit.health : {};
+  const healthCounts = isRecord2(health.counts) ? health.counts : {};
+  const healthByStatus = isRecord2(healthCounts.by_status) ? healthCounts.by_status : {};
+  const autoCompact = isRecord2(health.auto_compact) ? health.auto_compact : {};
+  const cleanCandidates = isRecord2(audit.cleanCandidates) ? audit.cleanCandidates : {};
+  const candidateCounts = isRecord2(cleanCandidates.counts) ? cleanCandidates.counts : {};
+  const compactDryRun = isRecord2(audit.compactDryRun) ? audit.compactDryRun : {};
+  const cleanupCandidateCounts = Object.fromEntries(
+    Object.entries(candidateCounts).map(([key, value]) => [key, numberLikeValue(value)]).filter((entry) => entry[1] !== void 0)
+  );
+  const totalScanned = numberLikeValue(health.total_scanned ?? cleanCandidates.total_scanned);
+  const activeCount = numberLikeValue(healthByStatus.active);
+  const autoCompactThreshold = numberLikeValue(autoCompact.threshold);
+  const autoCompactWouldTrigger = autoCompact.would_trigger_by_count === true;
+  const compactDryRunPlannedActions = numberLikeValue(
+    compactDryRun.planned_actions ?? compactDryRun.plannedActions
+  );
+  const recommendedActions = [];
+  const scope = audit.scope ?? "project";
+  if (autoCompactWouldTrigger || activeCount !== void 0 && autoCompactThreshold !== void 0 && activeCount > autoCompactThreshold) {
+    recommendedActions.push(
+      `snipara-companion memory clean-candidates --scope ${scope} --limit-per-bucket 5`
+    );
+    recommendedActions.push(
+      `snipara-companion memory compact --scope ${scope} --archive-older-than-days 30`
+    );
+  }
+  if (Object.values(cleanupCandidateCounts).some((count) => count > 0)) {
+    recommendedActions.push(
+      'snipara-companion memory-guard check --intent "apply memory cleanup" --destructive --strict'
+    );
+  }
+  return {
+    ...totalScanned !== void 0 ? { totalScanned } : {},
+    ...activeCount !== void 0 ? { activeCount } : {},
+    ...autoCompactThreshold !== void 0 ? { autoCompactThreshold } : {},
+    ...Object.keys(autoCompact).length > 0 ? { autoCompactWouldTrigger } : {},
+    cleanupCandidateCounts,
+    ...typeof compactDryRun.mutated === "boolean" ? { compactDryRunMutated: compactDryRun.mutated } : {},
+    ...compactDryRunPlannedActions !== void 0 ? { compactDryRunPlannedActions } : {},
+    recommendedActions: uniqueStrings3(recommendedActions)
+  };
+}
+function uniqueStrings3(values) {
+  return Array.from(new Set(values));
+}
+function printMemoryAuditSummary(summary) {
+  console.log(import_chalk3.default.bold("Memory Hygiene Summary"));
+  if (summary.totalScanned !== void 0) {
+    console.log(`Scanned: ${summary.totalScanned}`);
+  }
+  if (summary.activeCount !== void 0) {
+    console.log(`Active: ${summary.activeCount}`);
+  }
+  if (summary.autoCompactThreshold !== void 0) {
+    console.log(
+      `Auto-compaction: threshold ${summary.autoCompactThreshold} | would trigger: ${summary.autoCompactWouldTrigger ? "yes" : "no"}`
+    );
+  }
+  if (Object.keys(summary.cleanupCandidateCounts).length > 0) {
+    console.log(
+      `Cleanup candidates: ${Object.entries(summary.cleanupCandidateCounts).map(([key, value]) => `${key}: ${value}`).join(" | ")}`
+    );
+  }
+  if (summary.recommendedActions.length > 0) {
+    console.log("Recommended actions:");
+    for (const action of summary.recommendedActions) {
+      console.log(`- ${action}`);
+    }
+  }
+}
 function printMemoryInvalidate(result) {
   console.log(import_chalk3.default.bold("Memory Invalidated"));
   console.log(`Memory: ${result.memory_id}`);
@@ -9119,6 +9201,7 @@ async function buildMemoryAudit(options) {
       message: error instanceof Error ? error.message : String(error)
     });
   }
+  result.summary = buildMemoryAuditSummary(result);
   return result;
 }
 async function memoryAuditCommand(options) {
@@ -9132,6 +9215,10 @@ async function memoryAuditCommand(options) {
     console.log(`Scope: ${audit.scope}`);
   }
   console.log("");
+  if (audit.summary) {
+    printMemoryAuditSummary(audit.summary);
+    console.log("");
+  }
   if (audit.health) {
     printMemoryHealth(audit.health);
     console.log("");
@@ -9163,7 +9250,7 @@ async function memoryAuditCommand(options) {
 var fs12 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
-function uniqueStrings3(values) {
+function uniqueStrings4(values) {
   return Array.from(new Set((values ?? []).map((value) => value.trim()).filter(Boolean)));
 }
 function slugify(value, fallback) {
@@ -9171,7 +9258,7 @@ function slugify(value, fallback) {
   return slug2 || fallback;
 }
 function keywordHints(value) {
-  return uniqueStrings3(
+  return uniqueStrings4(
     value.split(/[^A-Za-z0-9_.:/-]+/).map((part) => part.trim()).filter((part) => part.length >= 4).slice(0, 8)
   );
 }
@@ -9217,17 +9304,17 @@ function expectedItems(section, values, files) {
 }
 function buildEvalCaseArtifact(options = {}) {
   const rootDir = path11.resolve(options.dir ?? process.cwd());
-  const files = uniqueStrings3(options.files);
-  const commandsRun = uniqueStrings3(options.commandRun);
+  const files = uniqueStrings4(options.files);
+  const commandsRun = uniqueStrings4(options.commandRun);
   const summary = options.summary?.trim() || "Snipara companion local workflow evaluation";
   const id = options.id?.trim() || slugify(summary, "snipara-companion-eval");
   const expected = {};
   const sectionInputs = {
-    context: uniqueStrings3(options.context),
-    decisions: uniqueStrings3(options.decision),
-    impact: uniqueStrings3(options.impact),
-    verification: uniqueStrings3(options.verification),
-    continuity: uniqueStrings3(options.continuity)
+    context: uniqueStrings4(options.context),
+    decisions: uniqueStrings4(options.decision),
+    impact: uniqueStrings4(options.impact),
+    verification: uniqueStrings4(options.verification),
+    continuity: uniqueStrings4(options.continuity)
   };
   for (const [section, values] of Object.entries(sectionInputs)) {
     if (values.length > 0) {
@@ -9370,7 +9457,7 @@ function detectRuntimeEnvironment(cwd = process.cwd(), env = process.env) {
   const workspaceRoot = findWorkspaceRoot(cwd);
   const mcpConfigPaths = findRuntimeMcpConfigPaths(cwd, workspaceRoot);
   const sandboxCli = detectSandboxCli();
-  const orchestratorCli = detectOrchestratorCli();
+  const orchestratorCli = detectOrchestratorCli(cwd, workspaceRoot);
   const parsedVersion = parseRuntimeVersion(sandboxCli.version);
   const providerKeys = detectProviderKeys(cwd, workspaceRoot, env);
   return {
@@ -9501,6 +9588,21 @@ function getCommandVersion(command) {
     return void 0;
   }
 }
+function executableExists(filePath) {
+  try {
+    const stat = fs13.statSync(filePath);
+    if (!stat.isFile()) {
+      return false;
+    }
+    if (process.platform === "win32") {
+      return true;
+    }
+    fs13.accessSync(filePath, fs13.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function detectSandboxCli() {
   for (const command of SANDBOX_COMMANDS) {
     const version = getCommandVersion(command);
@@ -9514,7 +9616,7 @@ function detectSandboxCli() {
   }
   return {};
 }
-function detectOrchestratorCli() {
+function detectOrchestratorCli(cwd, workspaceRoot) {
   const version = getCommandVersion(ORCHESTRATOR_COMMAND);
   if (version || commandExists(ORCHESTRATOR_COMMAND)) {
     return {
@@ -9522,8 +9624,33 @@ function detectOrchestratorCli() {
       version
     };
   }
+  for (const candidate of findWorkspaceExecutableCandidates(
+    ORCHESTRATOR_COMMAND,
+    cwd,
+    workspaceRoot
+  )) {
+    if (!executableExists(candidate)) {
+      continue;
+    }
+    return {
+      command: candidate,
+      version: getCommandVersion(candidate)
+    };
+  }
   return {};
 }
+function findWorkspaceExecutableCandidates(command, cwd, workspaceRoot) {
+  const executableName = process.platform === "win32" ? `${command}.exe` : command;
+  const roots = Array.from(
+    new Set([workspaceRoot, path12.resolve(cwd)].filter((value) => Boolean(value)))
+  );
+  return roots.flatMap((root) => [
+    path12.join(root, ".venv", "bin", executableName),
+    path12.join(root, "venv", "bin", executableName),
+    path12.join(root, "packages", "agentic-orchestrator", ".venv", "bin", executableName),
+    path12.join(root, "apps", "mcp-server", ".venv", "bin", executableName)
+  ]);
+}
 function parseRuntimeVersion(version) {
   if (!version) {
     return {};
@@ -10590,7 +10717,7 @@ function normalizeStringList(values) {
 }
 
 // src/commands/journal.ts
-function uniqueStrings4(values) {
+function uniqueStrings5(values) {
   if (!values) {
     return [];
   }
@@ -10618,7 +10745,7 @@ function buildJournalCheckpointEntry(payload) {
     payload.actor ? `Actor: ${payload.actor}` : null,
     payload.attention ? `Attention: ${payload.attention}` : null,
     payload.next ? `Next: ${payload.next}` : null,
-    uniqueStrings4(payload.files).length > 0 ? `Files: ${uniqueStrings4(payload.files).join(", ")}` : null
+    uniqueStrings5(payload.files).length > 0 ? `Files: ${uniqueStrings5(payload.files).join(", ")}` : null
   ].filter((line) => Boolean(line));
   return {
     text: lines.join("\n"),
@@ -10703,6 +10830,13 @@ function buildTeamSyncSummary(state, since, now = /* @__PURE__ */ new Date()) {
       files.add(file);
     }
   }
+  const staleWorkExplanation = buildStaleWorkExplanation(
+    work,
+    staleWork,
+    completedWork,
+    archivedWork,
+    now
+  );
   return {
     activeWorkCount: activeWork.length,
     staleWorkCount: staleWork.length,
@@ -10710,13 +10844,8 @@ function buildTeamSyncSummary(state, since, now = /* @__PURE__ */ new Date()) {
     archivedWorkCount: archivedWork.length,
     handoffCount: handoffs.length,
     files: Array.from(files).sort(),
-    staleWorkExplanation: buildStaleWorkExplanation(
-      work,
-      staleWork,
-      completedWork,
-      archivedWork,
-      now
-    ),
+    staleWorkExplanation,
+    hygieneActions: buildTeamSyncHygieneActions(staleWork, staleWorkExplanation),
     latestActiveWork: activeWork[activeWork.length - 1],
     latestStaleWork: staleWork[staleWork.length - 1],
     latestCompletedWork: completedWork[completedWork.length - 1],
@@ -10724,6 +10853,42 @@ function buildTeamSyncSummary(state, since, now = /* @__PURE__ */ new Date()) {
     latestHandoff: handoffs[handoffs.length - 1]
   };
 }
+function buildTeamSyncHygieneActions(staleWork, explanation) {
+  if (staleWork.length === 0) {
+    return [];
+  }
+  const actions = [];
+  if (explanation.autoArchivableCount > 0) {
+    actions.push({
+      kind: "sweep-preview",
+      command: `snipara-companion team-sync sweep --days ${explanation.autoArchiveAfterDays} --dry-run`,
+      reason: `${explanation.autoArchivableCount} stale active item(s) are old enough to archive.`,
+      mutates: false
+    });
+    actions.push({
+      kind: "sweep-archive",
+      command: `snipara-companion team-sync sweep --days ${explanation.autoArchiveAfterDays}`,
+      reason: "Archive stale local Team Sync work without deleting history.",
+      mutates: true
+    });
+  }
+  const latest = staleWork[staleWork.length - 1];
+  if (latest) {
+    actions.push({
+      kind: "complete-work",
+      command: `snipara-companion team-sync complete-work --id ${latest.id} --next '<completion reason>'`,
+      reason: "Close the latest stale item if the work is actually done.",
+      mutates: true
+    });
+    actions.push({
+      kind: "handoff",
+      command: "snipara-companion team-sync handoff --summary '<current state>' --next '<next action>' --attention watch",
+      reason: "Refresh continuity if the stale work is still active.",
+      mutates: true
+    });
+  }
+  return actions;
+}
 function buildStaleWorkExplanation(work, staleWork, completedWork, archivedWork, now) {
   const autoArchivableCount = work.filter(
     (item) => item.status === "active" && now.getTime() - getWorkTimestamp(item) > TEAM_SYNC_AUTO_ARCHIVE_WORK_MS
@@ -11574,6 +11739,12 @@ function printTeamSyncResult(payload, json) {
   if (summary.staleWorkCount > 0) {
     console.log(`Stale detail: ${summary.staleWorkExplanation.message}`);
   }
+  if (summary.hygieneActions.length > 0) {
+    console.log("Hygiene actions:");
+    for (const action2 of summary.hygieneActions.slice(0, 4)) {
+      console.log(`- ${action2.command} (${action2.reason})`);
+    }
+  }
   if (summary.files.length > 0) {
     console.log(`Files: ${summary.files.slice(0, 8).join(", ")}`);
   }
@@ -12429,16 +12600,16 @@ function upsertLocalAdaptiveRoutingPolicy(workerRole) {
     mode: stringValue3(existing.mode) ?? "catalog",
     plannerRetainsReasoning: existing.plannerRetainsReasoning !== false,
     preferLocalWorkers: true,
-    allowedEndpointTypes: uniqueStrings5([
+    allowedEndpointTypes: uniqueStrings6([
       ...normalizeStringList2(existing.allowedEndpointTypes),
       "local",
       "cloud"
     ]),
-    preferredEndpointTypes: uniqueStrings5([
+    preferredEndpointTypes: uniqueStrings6([
       "local",
       ...normalizeStringList2(existing.preferredEndpointTypes)
     ]),
-    allowedWorkerClasses: uniqueStrings5([
+    allowedWorkerClasses: uniqueStrings6([
       ...normalizeStringList2(existing.allowedWorkerClasses),
       workerRole,
       "documentation",
@@ -12498,9 +12669,9 @@ function defaultCapabilitiesForWorker(workerRole) {
 }
 function normalizeStringList2(value) {
   const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
-  return uniqueStrings5(values.map(stringValue3).filter((item) => Boolean(item)));
+  return uniqueStrings6(values.map(stringValue3).filter((item) => Boolean(item)));
 }
-function uniqueStrings5(values) {
+function uniqueStrings6(values) {
   return Array.from(new Set(values));
 }
 function stringValue3(value) {
@@ -12645,7 +12816,7 @@ function numberValue2(value) {
   const parsed = Number(text);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-function uniqueStrings6(values) {
+function uniqueStrings7(values) {
   return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
 }
 function normalizeEnum(value) {
@@ -15255,8 +15426,8 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       runtimeCatalog: catalog,
       routingCard: {
         ...routing.routingCard,
-        reasons: uniqueStrings6(reasons),
-        warnings: uniqueStrings6([...routing.routingCard.warnings, ...gatewayWarnings])
+        reasons: uniqueStrings7(reasons),
+        warnings: uniqueStrings7([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -15273,7 +15444,7 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings6([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings7([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -15439,7 +15610,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
     const approvalRequired = booleanValue(
       isRecord6(resolution?.policyDecision) ? resolution.policyDecision.approvalRequired : void 0
     );
-    const gatewayWarnings = uniqueStrings6([
+    const gatewayWarnings = uniqueStrings7([
       ...resolutionWarnings,
       ...selectedCandidate ? [] : ["Local orchestrator did not select a worker candidate and will fail closed."]
     ]);
@@ -15460,7 +15631,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
         ...routing.routingCard,
         ...selectedCandidate?.workerClass ? { recommendedWorkerClass: selectedCandidate.workerClass } : {},
         ...approvalRequired !== void 0 ? { humanApprovalRequired: approvalRequired } : {},
-        reasons: uniqueStrings6([
+        reasons: uniqueStrings7([
           ...routing.routingCard.reasons,
           ...resolutionReasons,
           ...selectedCandidate ? [
@@ -15469,7 +15640,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
             ...stringValue4(selectedEndpoint?.model) ? [`selected local model ${String(selectedEndpoint?.model)}`] : []
           ] : ["local orchestrator could not resolve a concrete worker candidate"]
         ]),
-        warnings: uniqueStrings6([...routing.routingCard.warnings, ...gatewayWarnings])
+        warnings: uniqueStrings7([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -15486,7 +15657,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings6([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings7([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -17289,8 +17460,8 @@ function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = [
     ...routing,
     routingCard: {
       ...routing.routingCard,
-      reasons: uniqueStrings6([...routing.routingCard.reasons, ...policyReasons]),
-      warnings: uniqueStrings6([...routing.routingCard.warnings, ...policyWarnings])
+      reasons: uniqueStrings7([...routing.routingCard.reasons, ...policyReasons]),
+      warnings: uniqueStrings7([...routing.routingCard.warnings, ...policyWarnings])
     }
   };
 }
@@ -17306,7 +17477,7 @@ function normalizeAdaptiveRoutingMode(value) {
   return normalized === "off" || normalized === "recommend" || normalized === "catalog" ? normalized : null;
 }
 function normalizeAdaptiveWorkerClasses(values) {
-  return uniqueStrings6((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
+  return uniqueStrings7((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
     (value) => ["documentation", "tests", "review", "coding"].includes(value)
   );
 }
@@ -21647,9 +21818,96 @@ function commandForPackageScript(info, scriptName, cwd) {
   }
   return `pnpm ${scriptName}`;
 }
+function shellQuote3(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function commandInDirectory(root, cwd, command) {
+  const relativeRoot = import_path4.default.relative(import_path4.default.resolve(cwd), import_path4.default.resolve(root));
+  if (!relativeRoot) {
+    return command;
+  }
+  return `cd ${shellQuote3(relativeRoot)} && ${command}`;
+}
+function isPythonSurface(filePath) {
+  const basename7 = import_path4.default.basename(filePath);
+  return filePath.endsWith(".py") || basename7 === "pyproject.toml" || basename7 === "requirements.txt" || basename7.startsWith("requirements-") || basename7 === "setup.py" || basename7 === "setup.cfg" || basename7 === "tox.ini";
+}
+function findPyproject(startPath, cwd) {
+  const absoluteStart = import_path4.default.resolve(cwd, startPath);
+  let current = import_fs4.default.existsSync(absoluteStart) && import_fs4.default.statSync(absoluteStart).isDirectory() ? absoluteStart : import_path4.default.dirname(absoluteStart);
+  const stop = import_path4.default.parse(import_path4.default.resolve(cwd)).root;
+  while (current !== stop) {
+    const candidate = import_path4.default.join(current, "pyproject.toml");
+    if (import_fs4.default.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = import_path4.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+function readPythonProject(pyprojectPath) {
+  try {
+    return {
+      root: import_path4.default.dirname(pyprojectPath),
+      pyprojectPath,
+      text: import_fs4.default.readFileSync(pyprojectPath, "utf8")
+    };
+  } catch {
+    return null;
+  }
+}
+function inferPythonChecks(changedFiles, cwd) {
+  const pyprojectFiles = unique4(
+    changedFiles.filter(isPythonSurface).map((file) => findPyproject(file, cwd)).filter((file) => typeof file === "string")
+  );
+  const projects = pyprojectFiles.map(readPythonProject).filter((info) => Boolean(info));
+  return projects.flatMap((info) => {
+    const checks = [
+      {
+        kind: "test",
+        title: "pytest for Python project",
+        command: commandInDirectory(info.root, cwd, "python -m pytest"),
+        source: "fallback",
+        reason: `Detected Python project at ${import_path4.default.relative(cwd, info.pyprojectPath)}.`
+      }
+    ];
+    if (/\[tool\.ruff(?:\.|\])/.test(info.text) || /\bruff\b/.test(info.text)) {
+      checks.push({
+        kind: "lint",
+        title: "ruff check for Python project",
+        command: commandInDirectory(info.root, cwd, "python -m ruff check ."),
+        source: "fallback",
+        reason: `Detected Ruff configuration or dependency in ${import_path4.default.relative(cwd, info.pyprojectPath)}.`
+      });
+    }
+    if (/\[tool\.mypy\]/.test(info.text) || /\bmypy\b/.test(info.text)) {
+      checks.push({
+        kind: "type-check",
+        title: "mypy for Python project",
+        command: commandInDirectory(info.root, cwd, "python -m mypy ."),
+        source: "fallback",
+        reason: `Detected mypy configuration or dependency in ${import_path4.default.relative(cwd, info.pyprojectPath)}.`
+      });
+    }
+    if (/\[build-system\]/.test(info.text)) {
+      checks.push({
+        kind: "build",
+        title: "build Python package",
+        command: commandInDirectory(info.root, cwd, "python -m build"),
+        source: "fallback",
+        reason: `Detected Python build system in ${import_path4.default.relative(cwd, info.pyprojectPath)}.`
+      });
+    }
+    return checks;
+  });
+}
 function inferPackageScriptChecks(changedFiles, cwd) {
   const packageFiles = unique4(
-    changedFiles.map((file) => findPackageJson(file, cwd)).filter((file) => typeof file === "string")
+    changedFiles.filter((file) => !(isPythonSurface(file) && findPyproject(file, cwd))).map((file) => findPackageJson(file, cwd)).filter((file) => typeof file === "string")
   );
   const packages = packageFiles.map(readPackageInfo).filter((info) => Boolean(info));
   const scriptKinds = [
@@ -21777,8 +22035,14 @@ function buildVerificationPlan(options) {
   const impactedFiles = collectImpactedFiles(options.codeImpact, changedFiles, options.filePath);
   const directChecks = collectDirectTestChecks(options.codeImpact);
   const actionChecks = collectActionChecks(options.codeImpact);
+  const pythonChecks = inferPythonChecks(impactedFiles, cwd);
   const packageChecks = inferPackageScriptChecks(impactedFiles, cwd);
-  const recommendedChecks = dedupeChecks([...directChecks, ...actionChecks, ...packageChecks]);
+  const recommendedChecks = dedupeChecks([
+    ...directChecks,
+    ...actionChecks,
+    ...pythonChecks,
+    ...packageChecks
+  ]);
   const missingChecks = collectCoverageGaps(options.codeImpact);
   if (!options.codeImpact) {
     missingChecks.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "Local-first CLI that asks your repo what breaks before an AI coding agent edits it.",
   "main": "dist/index.js",
   "bin": {