snipara-companion 3.2.6 → 3.2.7

package/README.md

@@ -133,9 +133,10 @@ verification hints.
 Session Snapshot V0 includes latest activity, risk reasons, touched files, a
 next action, and advisory Intent Detection V0. Intent Detection V0 reports the
 inferred intent, confidence, reason-code signals, local evidence counts, and a
-suggested workflow mode hint for the human or agent to consider. It is
-observational and keeps `hardRoutingAllowed=false` until explicit routing policy
-and receipts exist.
+suggested workflow mode. `workflow run --mode auto` uses that same Control Plane
+principle to choose lite, standard, full, or orchestrate. Lite runs with zero
+mandatory hosted context calls; recall/context/code-impact are on-demand
+escalations, not an entry toll.
 `workflow timeline --export md` prints a compact redacted Markdown timeline for
 handoff or publication.
 

package/dist/index.js

@@ -18886,11 +18886,23 @@ function resolveAutoWorkflowMode(query) {
   )) {
     return "full";
   }
+  if (/\b(why|pourquoi|decision|décision|rationale|positioning|positionnement|strategy|stratégie|cross-session|previous decision|prior decision|historical context)\b/.test(
+    normalized
+  )) {
+    return "standard";
+  }
   if (/\b(status|show|list|read|lookup|recall|brief|summarize|summary|what changed|question|docs?|documentation)\b/.test(
     normalized
   ) && !/\b(implement|change|fix|ship|code|refactor|test|write|create|build)\b/.test(normalized)) {
     return "lite";
   }
+  if (/\b(typo|copy edit|small diff|tiny diff|one-line|one line|known file|obvious fix|quick fix|format|formatting|rename)\b/.test(
+    normalized
+  ) && !/\b(architecture|release|deploy|migration|schema|auth|billing|security|multi-file|many files|5\+ files|cross-session|decision|décision)\b/.test(
+    normalized
+  )) {
+    return "lite";
+  }
   return "standard";
 }
 function effectiveWorkflowMode(mode, query = "") {
@@ -18939,14 +18951,15 @@ function safeDecisionPendingCount() {
 function printManagedWorkflowDiscipline() {
   console.log(import_chalk6.default.bold("Coding workflow mode"));
   console.log(
-    "- LITE: small single-phase edits still start with Snipara recall/context and end with local verification."
+    "- LITE: small single-phase edits have no mandatory Snipara calls; use local verification and escalate on demand."
   );
   console.log(
-    "- STANDARD: normal coding work uses context plus recommended code-graph follow-up; --mode auto deterministically selects lite/standard/full/orchestrate from task intent."
+    "- STANDARD: normal coding work uses context or code graph when the task needs source truth or prior rationale."
   );
   console.log(
     "- FULL: use this managed workflow with phases/chunks for multi-file, risky, release/deploy, architectural, or compaction-prone coding work."
   );
+  console.log("- --mode auto routes by task intent; a nudge is advisory, not a gate.");
   console.log(
     "- FULL + ORCHESTRATED: use explicit snipara-orchestrator handoff only for production gates, drift checks, htasks, or multi-agent coordination."
   );
@@ -20026,6 +20039,17 @@ function printRuntimeHint(query, mode) {
   console.log("Fresh setup: npx create-snipara --profile full-stack --advanced");
   console.log("Manual install: pip install 'snipara-sandbox[all]'");
 }
+function printLiteWorkflowRun(query, requestedMode) {
+  console.log(import_chalk6.default.bold("Workflow Lite"));
+  printKeyValue2("Requested mode:", requestedMode);
+  printKeyValue2("Effective mode:", "lite");
+  printKeyValue2("Task:", query);
+  console.log("No Snipara recall, context query, or bootstrap call was run.");
+  console.log(
+    "Escalate with recall, context_query, code impact, or task-commit only when the task creates that need."
+  );
+  console.log("");
+}
 function runtimeHintVersionLabel(report) {
   if (!report.runtime.cliVersion) {
     return report.runtime.version ? ` (${report.runtime.version})` : "";
@@ -20722,37 +20746,29 @@ function printChunkResult(chunkId, result) {
 function readSessionEntryPreview(entry) {
   return toPreview(entry.text ?? entry.content ?? entry.summary ?? entry.title, 220);
 }
-function printSessionTier(label, tier) {
-  if (tier.memories.length === 0) {
-    return;
-  }
-  console.log(import_chalk6.default.bold(label));
-  for (const entry of tier.memories.slice(0, 5)) {
-    console.log(`- ${readSessionEntryPreview(entry)}`);
-  }
-  console.log("");
+function compactSessionEntryLine(entry) {
+  const label = typeof entry.type === "string" && entry.type.trim().length > 0 ? entry.type.trim() : typeof entry.category === "string" && entry.category.trim().length > 0 ? entry.category.trim() : "memory";
+  return `- ${label}: ${readSessionEntryPreview(entry)}`;
 }
 function printSessionBootstrap(result, options) {
   const normalized = normalizeSessionMemoriesResult(result);
-  printKeyValue2("Durable memory:", normalized.critical.count);
-  printKeyValue2(
-    "Session context:",
-    options.includeSessionContext ? normalized.daily.count : "skipped by default (use --include-session-context)"
-  );
-  if (typeof normalized.total_tokens === "number") {
-    printKeyValue2("Tokens:", normalized.total_tokens);
-  }
-  if (typeof normalized.message === "string" && normalized.message.length > 0) {
-    printKeyValue2("Message:", normalized.message);
+  const entries = [
+    ...normalized.critical.memories,
+    ...options.includeSessionContext ? normalized.daily.memories : []
+  ].slice(0, 5);
+  if (entries.length === 0) {
+    return false;
   }
-  console.log("");
-  printSessionTier("Durable Memory", normalized.critical);
-  if (options.includeSessionContext) {
-    printSessionTier("Session Context (weak carryover)", normalized.daily);
+  console.log(import_chalk6.default.bold("Snipara Bootstrap Brief"));
+  for (const entry of entries) {
+    console.log(compactSessionEntryLine(entry));
   }
-  if (normalized.critical.count === 0 && normalized.daily.count === 0) {
-    printJson2(normalized);
+  const hiddenCount = normalized.critical.count + (options.includeSessionContext ? normalized.daily.count : 0) - entries.length;
+  if (hiddenCount > 0) {
+    console.log(`- ${hiddenCount} more available on demand via recall/session-bootstrap --json.`);
   }
+  console.log("");
+  return true;
 }
 function printSessionBootstrapQuality(report) {
   if (report.warnings.length === 0) {
@@ -22039,10 +22055,11 @@ async function sharedContextCommand(options) {
 }
 async function workflowRunCommand(options) {
   const hostedConfigured = isConfigured();
+  const effectiveMode = effectiveWorkflowMode(options.mode, options.query);
   const localAdaptiveRoutingPolicy = readLocalAdaptiveRoutingProjectPolicy();
   const localAdaptiveRoutingRequested = shouldBuildAdaptiveRouting(options);
-  const canRunLocalAdaptiveRouting = !hostedConfigured && options.mode !== "orchestrate" && (localAdaptiveRoutingRequested || localAdaptiveRoutingPolicy !== null && localAdaptiveRoutingPolicy.mode !== "off");
-  if (!hostedConfigured && !canRunLocalAdaptiveRouting) {
+  const canRunLocalAdaptiveRouting = !hostedConfigured && effectiveMode !== "orchestrate" && (localAdaptiveRoutingRequested || localAdaptiveRoutingPolicy !== null && localAdaptiveRoutingPolicy.mode !== "off");
+  if (!hostedConfigured && !canRunLocalAdaptiveRouting && effectiveMode !== "lite") {
     ensureConfigured();
   }
   const client = hostedConfigured ? createClient(2e4) : null;
@@ -22068,7 +22085,6 @@ async function workflowRunCommand(options) {
     routingOptions,
     adaptiveRoutingWithCatalog
   ) ? enrichAdaptiveRoutingWithLocalOrchestrator(adaptiveRoutingWithCatalog, routingOptions) : adaptiveRoutingWithCatalog;
-  const effectiveMode = effectiveWorkflowMode(options.mode, options.query);
   const orchestratorRecommendation = getOrchestratorRecommendation(options.query, effectiveMode, {
     policyAutoRoute: options.autoRouteOrchestrator,
     policySource: options.orchestratorPolicySource,
@@ -22090,11 +22106,16 @@ async function workflowRunCommand(options) {
       effective_mode: effectiveMode,
       local_only: true,
       local_policy_path: localAdaptiveRoutingPolicy ? ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH2 : null,
+      retrieval_policy: effectiveMode === "lite" ? {
+        mandatory_calls: [],
+        escalation: "Run recall, context_query, or code impact only when the task needs them.",
+        persistence: "Use task-commit only when reusable durable knowledge was learned."
+      } : void 0,
       orchestrator_recommendation: orchestratorRecommendation,
       orchestrator_handoff: preparedHandoff,
       adaptive_routing: adaptiveRouting,
       local_worker: localWorkerRoutingDefaults?.worker,
-      warnings: [
+      warnings: effectiveMode === "lite" ? [] : [
         "Hosted Snipara is not configured; workflow run is limited to local Adaptive Work Routing metadata."
       ]
     };
@@ -22102,10 +22123,44 @@ async function workflowRunCommand(options) {
       printJson2(payload2);
       return;
     }
-    console.log(import_chalk6.default.bold("Local Adaptive Work Routing"));
-    console.log(
-      "Hosted Snipara is not configured; no context query, hosted catalog, or planner call ran."
-    );
+    if (effectiveMode === "lite") {
+      printLiteWorkflowRun(options.query, options.mode);
+    } else {
+      console.log(import_chalk6.default.bold("Local Adaptive Work Routing"));
+      console.log(
+        "Hosted Snipara is not configured; no context query, hosted catalog, or planner call ran."
+      );
+    }
+    if (adaptiveRouting) {
+      printAdaptiveRoutingRecommendation(adaptiveRouting);
+    }
+    if (preparedHandoff) {
+      printPreparedOrchestratorHandoff2(preparedHandoff);
+    }
+    return;
+  }
+  if (effectiveMode === "lite") {
+    const payload2 = {
+      mode: options.mode,
+      effective_mode: effectiveMode,
+      retrieval_policy: {
+        mandatory_calls: [],
+        escalation: "Run recall, context_query, or code impact only when the task needs them.",
+        persistence: "Use task-commit only when reusable durable knowledge was learned."
+      },
+      orchestrator_recommendation: orchestratorRecommendation,
+      orchestrator_handoff: preparedHandoff,
+      adaptive_routing: adaptiveRouting,
+      local_worker: localWorkerRoutingDefaults?.worker
+    };
+    if (options.json) {
+      printJson2(payload2);
+      return;
+    }
+    printLiteWorkflowRun(options.query, options.mode);
+    if (options.runtimeHint !== false) {
+      printRuntimeHint(options.query, effectiveMode);
+    }
     if (adaptiveRouting) {
       printAdaptiveRoutingRecommendation(adaptiveRouting);
     }
@@ -22231,11 +22286,13 @@ async function workflowRunCommand(options) {
     return;
   }
   if (effectiveMode === "full" && payload.session_bootstrap) {
-    console.log(import_chalk6.default.bold("Workflow Bootstrap"));
-    printSessionBootstrap(payload.session_bootstrap, {
-      includeSessionContext: Boolean(workflowBudget?.include_session_context)
-    });
-    if (payload.session_bootstrap_quality && typeof payload.session_bootstrap_quality === "object") {
+    const printedBootstrap = printSessionBootstrap(
+      payload.session_bootstrap,
+      {
+        includeSessionContext: Boolean(workflowBudget?.include_session_context)
+      }
+    );
+    if (printedBootstrap && payload.session_bootstrap_quality && typeof payload.session_bootstrap_quality === "object") {
       printSessionBootstrapQuality(
         payload.session_bootstrap_quality
       );
@@ -23181,10 +23238,12 @@ async function workflowResumeCommand(options) {
   }
   console.log(import_chalk6.default.bold("Workflow Resume"));
   printManagedWorkflowState(state);
-  printSessionBootstrap(bootstrap, {
+  const printedBootstrap = printSessionBootstrap(bootstrap, {
     includeSessionContext: resolvedContextTokens > 0
   });
-  printSessionBootstrapQuality(bootstrapQuality);
+  if (printedBootstrap) {
+    printSessionBootstrapQuality(bootstrapQuality);
+  }
   printWorkflowLocalSessionSnapshot(localSessionSnapshot);
   printWorkflowTeamSyncResume(teamSyncResume);
   printWorkflowRuntimeResumePlan(runtimeResume);
@@ -23706,11 +23765,13 @@ async function sessionBootstrapCommand(options) {
     });
     return;
   }
-  printSessionBootstrap(result, {
+  const printedBootstrap = printSessionBootstrap(result, {
     includeSessionContext: resolvedContextTokens > 0
   });
-  printSessionBootstrapQuality(bootstrapQuality);
-  if (warmSnapshot.storedEntries > 0) {
+  if (printedBootstrap) {
+    printSessionBootstrapQuality(bootstrapQuality);
+  }
+  if (printedBootstrap && warmSnapshot.storedEntries > 0) {
     printKeyValue2(
       "Warm cache:",
       `${warmSnapshot.storedEntries} bootstrap memory/context entries primed locally`

package/docs/FULL_REFERENCE.md

@@ -930,7 +930,9 @@ without an extra LLM provider key because your AI client supplies the reasoning;
 runtime-bound phases it also restores the recorded Sandbox binding and prints a reattach or
 rehydrate plan. It does not snapshot or exactly restore a live Snipara Sandbox or REPL process.
 Short-lived session context is skipped unless you pass `--include-session-context`
-or an explicit `--max-context-tokens`; durable memory still loads by default.
+or an explicit `--max-context-tokens`. Text output is a compact bootstrap brief
+and is silent when no high-signal item is available; use `--json` for the full
+payload.
 `workflow run --mode full --json` also reports `workflow_budget`,
 `session_bootstrap_quality`, and `plan_quality.warnings` so agents can detect
 oversized bootstrap context or weak generated-plan file hints before editing.
@@ -1121,16 +1123,16 @@ snipara-companion workflow scaffold \
 ### Context vs Memory
 
 - Use `snipara-companion query`, `shared-context`, and `load-document` for source truth.
-- Use `snipara-companion recall`, `session-bootstrap`, and `task-commit` for durable memory.
+- Use `snipara-companion recall`, `session-bootstrap`, and `task-commit` for durable memory when the task needs it.
 - Do not use memory as a substitute for document retrieval.
 - Do not upload specs or raw documents into memory.
 
 Semantics:
 
 - `snipara-companion query --follow-recommendation` = execute the hosted recommended structural tool instead of only printing it
-- `snipara-companion workflow run --mode lite` = focused context query for small known-file work
+- `snipara-companion workflow run --mode lite` = zero mandatory hosted calls for small known-file work
 - `snipara-companion workflow run --mode standard` = context query plus automatic `snipara_code_*` follow-up when Snipara recommends one
-- `snipara-companion workflow run --mode auto` = compatibility alias for STANDARD behavior
+- `snipara-companion workflow run --mode auto` = routes to lite, standard, full, or orchestrate from task intent
 - `snipara-companion workflow run --mode full` = budgeted durable bootstrap + optional session context + context query + automatic structural follow-up + hosted plan with quality diagnostics
 - `snipara-companion plan --write-plan-file ./plan.json` = convert hosted `snipara_plan` output into managed workflow JSON
 - `snipara-companion plan --start-workflow` or `workflow run --mode full --start-workflow-from-plan` = create local `.snipara/workflow/current.json` from a valid generated plan
@@ -1193,13 +1195,15 @@ Semantics:
 - `snipara-companion reindex` = trigger or poll hosted `snipara_reindex`; use after uploads when immediate chunk availability matters
 - `snipara-companion code *` = direct access to the code graph tools without routing through `snipara_context_query`
 - `snipara-companion recall` = direct durable memory lookup for decisions, learnings, preferences, and carryover
-- `snipara-companion session-bootstrap` = durable memory first, optional weak session carryover second
+- `snipara-companion session-bootstrap` = pushed compact brief of durable memory first, optional weak session carryover second; empty brief is silent in text mode
 - `snipara-companion task-commit` = durable task/phase/workflow outcomes only, not a mechanical mirror of every Git commit
-- `snipara-companion memory-guard check` = forced memory/context recall before retries, commits, or finalization when a command failed or a publishable package surface is touched
+- `snipara-companion memory-guard check` = deterministic guard recall/context before retries, commits, or finalization when a command failed or a publishable package surface is touched
 - `snipara-companion memory-guard check --intent "<action>" --destructive --strict` = contradiction check before irreversible actions; blocks until the user explicitly confirms when memory/context disagrees or the action is destructive
 - `snipara-companion memory-guard remember --guard-tag pre-commit --text "..."` = create a project/team memory in a guard category such as `pre-commit`, `commit`, `failure`, `pre-final`, or `workflow-policy`
 - `--max-daily-tokens` is still accepted as a compatibility alias for `--max-context-tokens`
 
+Use Outcome Loop data to calibrate these defaults: for small tasks, compare whether entry recall/context actually preceded retained commits before promoting a nudge into a gate.
+
 ### Memory Guard Before Commit Or Destructive Actions
 
 Memory Guard is deterministic, not a user preference. It detects two global signals:

package/package.json

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