snipara-companion 3.2.2 → 3.2.3

package/README.md

@@ -71,6 +71,7 @@ npx -y snipara-companion workflow producer-triage
 npx -y snipara-companion workflow decisions
 npx -y snipara-companion workflow decide decision-abc123 --choose accept_all --reviewer alice
 npx -y snipara-companion workflow timeline
+npx -y snipara-companion workflow timeline --export md
 npx -y snipara-companion workflow session --json
 npx -y snipara-companion workflow producer-report
 npx -y snipara-companion workflow producer-review --latest --outcome useful --reviewer alice
@@ -84,8 +85,14 @@ verification hints.
 `workflow timeline` reads the append-only activity log at
 `.snipara/activity/timeline.jsonl`. `workflow session` derives
 `.snipara/activity/session.json` for fast local resume and Orchestrator dogfood;
-Session Snapshot V0 is observational and keeps `hardRoutingAllowed=false` until
-explicit routing policy and receipts exist.
+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.
+`workflow timeline --export md` prints a compact redacted Markdown timeline for
+handoff or publication.
 
 Workflow `phase-commit` and `final-commit` also emit Producer Loop artifacts
 under `.snipara/producer-loop/`. These are local review evidence backed by the
@@ -116,7 +123,9 @@ Other producers such as `outcome-capture preview --emit-decisions`,
 paths declared; they do not write canonical memory directly. `memory reviews`
 is the hosted-memory review connector: it reads review queue, cleanup, and
 duplicate candidate surfaces, summarizes the items for the LLM, and only writes
-local Decision Requests when `--emit-decisions` is passed.
+local Decision Requests when `--emit-decisions` is passed. Its JSON output
+includes `emittedCount`, `emittedRequestIds`, and an `emitted` summary so an
+agent can continue without re-listing pending requests.
 
 ## Local First, Hosted When Useful
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ProjectRealityCheckResult, ProjectIntelligenceEngineeringLeadPlanSummary } from '@snipara/project-intelligence-contracts';
+import { ProjectIntentDetectionResult, ProjectRealityCheckResult, ProjectIntelligenceEngineeringLeadPlanSummary } from '@snipara/project-intelligence-contracts';
 
 declare function resolveQueryFromToolInput(toolInput?: string, tool?: string): string | null;
 
@@ -1563,6 +1563,16 @@ interface SessionSnapshot {
         handoffCount: number;
         latestHandoffAt?: string;
     };
+    summary: {
+        latestActivityAt?: string;
+        latestActivityTitle?: string;
+        latestActivityKind?: string;
+        risk: "none" | "watch" | "risk";
+        riskReasons: string[];
+        touchedFiles: string[];
+        recommendedNextAction: string;
+    };
+    intentDetection: ProjectIntentDetectionResult;
     routing: {
         hardRoutingAllowed: false;
         reason: string;
@@ -1600,6 +1610,7 @@ declare function writeSessionSnapshot(options?: {
     cwd?: string;
     limit?: number;
 }): SessionSnapshot;
+declare function readSessionSnapshot(cwd?: string): SessionSnapshot | null;
 
 type LocalCodeOverlayMode = "working_tree" | "local_commit";
 type LocalCodeOverlayKind = "none" | "local_commit" | "working_tree" | "mixed";
@@ -2017,6 +2028,7 @@ interface ProjectIntelligenceBrief {
     memoryHealth?: Record<string, unknown>;
     codeImpact?: Record<string, unknown>;
     codeImpactSourceSelection?: CodeGraphSourceSelection;
+    localSessionSnapshot?: SessionSnapshot;
     verificationPlan?: VerificationPlan;
     judgmentCard?: ProjectIntelligenceJudgmentCard;
     errors: Array<{
@@ -4212,4 +4224,4 @@ declare function buildOrchestratorHandoff(options: OrchestratorHandoffOptions):
 declare function buildAdaptiveWorkRoutingRecommendation(options: AdaptiveWorkRoutingOptions): AdaptiveWorkRoutingRecommendation;
 declare function writeOrchestratorHandoff(options: OrchestratorHandoffOptions): WrittenOrchestratorHandoff;
 
-export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, CODING_INTELLIGENCE_LEDGER_VERSION, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES, ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_PROOF_VERIFICATION_SOURCES, ENGINEERING_LEAD_PROOF_VERIFICATION_STATUSES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, PRODUCER_LOOP_ARTIFACT_VERSION, PRODUCER_LOOP_RELATIVE_DIR, PRODUCER_LOOP_REPORT_VERSION, TEAM_SYNC_STATE_RELATIVE_PATH, WHY_OUTCOME_CAPTURE_VERSION, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, addLocalWorker, agentReadinessAuditCommand, appendActivityEvent, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCodingIntelligenceLedger, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectRealityCheck, buildLocalShortestPathResult, buildLocalSourceSnapshot, buildLocalSourceStatus, buildLocalSourceSyncResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProducerLoopReport, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapQuality, buildSessionSnapshot, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWhyOutcomeCaptureReport, buildWorkflowImpactGate, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, codingLedgerExportCommand, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, compareLocalSourceSnapshots, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getLocalSourceSnapshotPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, memoryReviewsCommand, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveLocalWorkerRoutingDefaults, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, workersLocalAddCommand, workersLocalStatusCommand, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeLocalSourceSnapshot, writeOrchestratorHandoff, writeProducerLoopArtifact, writeSessionSnapshot };
+export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, CODING_INTELLIGENCE_LEDGER_VERSION, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES, ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_PROOF_VERIFICATION_SOURCES, ENGINEERING_LEAD_PROOF_VERIFICATION_STATUSES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, PRODUCER_LOOP_ARTIFACT_VERSION, PRODUCER_LOOP_RELATIVE_DIR, PRODUCER_LOOP_REPORT_VERSION, TEAM_SYNC_STATE_RELATIVE_PATH, WHY_OUTCOME_CAPTURE_VERSION, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, addLocalWorker, agentReadinessAuditCommand, appendActivityEvent, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCodingIntelligenceLedger, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectRealityCheck, buildLocalShortestPathResult, buildLocalSourceSnapshot, buildLocalSourceStatus, buildLocalSourceSyncResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProducerLoopReport, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapQuality, buildSessionSnapshot, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWhyOutcomeCaptureReport, buildWorkflowImpactGate, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, codingLedgerExportCommand, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, compareLocalSourceSnapshots, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getLocalSourceSnapshotPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, memoryReviewsCommand, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, readSessionSnapshot, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveLocalWorkerRoutingDefaults, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, workersLocalAddCommand, workersLocalStatusCommand, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeLocalSourceSnapshot, writeOrchestratorHandoff, writeProducerLoopArtifact, writeSessionSnapshot };

package/dist/index.js

@@ -188,6 +188,7 @@ __export(index_exports, {
   readLocalCodePromotionState: () => readLocalCodePromotionState,
   readLocalSourceSnapshot: () => readLocalSourceSnapshot,
   readLocalWorkersConfig: () => readLocalWorkersConfig,
+  readSessionSnapshot: () => readSessionSnapshot,
   realityCheckCommand: () => realityCheckCommand,
   referencesIngestCommand: () => referencesIngestCommand,
   referencesScanCommand: () => referencesScanCommand,
@@ -10139,6 +10140,231 @@ function sortJsonValue(value) {
   return value;
 }
 
+// ../project-intelligence-contracts/src/intent-detection.ts
+var INTENT_DETECTION_VERSION = "snipara.intent_detection.v0";
+var PROJECT_INTENT_DETECTION_INTENTS = [
+  "debugging",
+  "implementing_feature",
+  "refactoring",
+  "reviewing",
+  "investigating",
+  "release_deploy",
+  "unknown"
+];
+var PROJECT_INTENT_DETECTION_ACTIONS = [
+  "read",
+  "write",
+  "test",
+  "build",
+  "deploy",
+  "review",
+  "decision",
+  "handoff",
+  "unknown"
+];
+var INTENT_PRIORITY = {
+  release_deploy: 60,
+  debugging: 50,
+  implementing_feature: 40,
+  refactoring: 30,
+  reviewing: 20,
+  investigating: 10,
+  unknown: 0
+};
+function textMatches(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+function uniqueStrings5(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function compactSignals(signals) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const existing = byCode.get(signal.code);
+    if (!existing || signal.weight > existing.weight) {
+      byCode.set(signal.code, signal);
+    }
+  }
+  return [...byCode.values()];
+}
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" ? value : "";
+}
+function inferAction(event) {
+  const explicitAction = metadataString(event.metadata, "action");
+  if (PROJECT_INTENT_DETECTION_ACTIONS.includes(explicitAction)) {
+    return explicitAction;
+  }
+  const text = [event.kind, event.source, event.title, event.summary, event.detail, event.outcome].filter(Boolean).join(" ").toLowerCase();
+  if (textMatches(text, [/\b(test|tests|spec|vitest|jest|pytest|node --test)\b/i])) return "test";
+  if (textMatches(text, [/\b(build|type-?check|lint|compile)\b/i])) return "build";
+  if (textMatches(text, [/\b(deploy|release|publish|rollout|production)\b/i])) return "deploy";
+  if (textMatches(text, [/\b(review|audit|inspect|read|look(ed)? at|rg|grep)\b/i])) return "read";
+  if (textMatches(text, [/\b(decision|decide|policy suggestion|manual apply)\b/i]))
+    return "decision";
+  if (textMatches(text, [/\b(handoff|resume|final-commit|phase-commit)\b/i])) return "handoff";
+  if (textMatches(text, [/\b(edit|write|add(ed)?|implement|fix|refactor|change(d)?)\b/i])) {
+    return "write";
+  }
+  return "unknown";
+}
+function normalizeEvent(event) {
+  return {
+    text: [event.kind, event.source, event.title, event.summary, event.detail, event.outcome].filter(Boolean).join(" ").toLowerCase(),
+    files: uniqueStrings5(event.files ?? []),
+    action: inferAction(event),
+    outcome: event.outcome?.toLowerCase()
+  };
+}
+function actionCount(events, action) {
+  return events.filter((event) => event.action === action).length;
+}
+function addSignal(scores, intent, code2, weight, detail) {
+  const signals = scores.get(intent) ?? [];
+  signals.push({ code: code2, intent, weight, ...detail ? { detail } : {} });
+  scores.set(intent, signals);
+}
+function confidenceFor(score, signalCount) {
+  if (score >= 7 && signalCount >= 3) return "high";
+  if (score >= 4 && signalCount >= 2) return "medium";
+  return "low";
+}
+function suggestedModeFor(intent, confidence, files) {
+  if (intent === "release_deploy") return "full";
+  if (intent === "refactoring" && (confidence !== "low" || files.length >= 5)) return "full";
+  if (intent === "debugging" && confidence === "high") return "standard";
+  if (intent === "investigating" || intent === "reviewing") return "lite";
+  return files.length >= 5 ? "standard" : "lite";
+}
+function buildIntentDetectionFromTimeline(events) {
+  const normalized = events.map(normalizeEvent);
+  const text = normalized.map((event) => event.text).join("\n");
+  const files = uniqueStrings5(normalized.flatMap((event) => event.files));
+  const testFiles2 = files.filter((file) => /(test|spec)\.|__tests__|tests?\//i.test(file));
+  const docsFiles = files.filter((file) => /(^|\/)(docs?|README|CHANGELOG)|\.md$/i.test(file));
+  const packageFiles = files.filter(
+    (file) => /package\.json|CHANGELOG|README|pyproject|setup\.py|publish/i.test(file)
+  );
+  const sourceFiles = files.filter((file) => /\.(ts|tsx|js|jsx|py|go|rs|java|rb)$/i.test(file));
+  const failureEvents = normalized.filter(
+    (event) => event.outcome === "failed" || textMatches(event.text, [/\b(fail(ed|ure)?|error|timeout|retry|regression)\b/i])
+  );
+  const scores = /* @__PURE__ */ new Map();
+  if (failureEvents.length > 0) {
+    addSignal(scores, "debugging", "failure_signal", 3, `${failureEvents.length} failure event(s)`);
+  }
+  if (testFiles2.length > 0 && (failureEvents.length > 0 || actionCount(normalized, "test") > 0)) {
+    addSignal(scores, "debugging", "test_loop_signal", 3, `${testFiles2.length} test file(s)`);
+  }
+  if (failureEvents.length > 0 && actionCount(normalized, "write") > 0 && files.some((file) => failureEvents.some((event) => event.files.includes(file)))) {
+    addSignal(scores, "debugging", "same_file_edited_after_failure", 2);
+  }
+  if (textMatches(text, [/\b(deploy|deployment|release|publish|production|rollout)\b/i])) {
+    addSignal(scores, "release_deploy", "release_or_deploy_terms", 3);
+  }
+  if (packageFiles.length > 0) {
+    addSignal(scores, "release_deploy", "package_or_release_files", 2);
+  }
+  if (docsFiles.length > 0 && packageFiles.length > 0) {
+    addSignal(scores, "release_deploy", "docs_plus_package_surface", 2);
+  }
+  if (actionCount(normalized, "deploy") > 0) {
+    addSignal(scores, "release_deploy", "deploy_action", 3);
+  }
+  if (textMatches(text, [/\b(feature|implement(ed|ing)?|add(ed|s)?|new behavior|ship)\b/i])) {
+    addSignal(scores, "implementing_feature", "feature_language", 3);
+  }
+  if (testFiles2.length > 0 && sourceFiles.length > 0) {
+    addSignal(scores, "implementing_feature", "tests_plus_product_files", 2);
+  }
+  if (actionCount(normalized, "write") > 0 && sourceFiles.length > 0) {
+    addSignal(scores, "implementing_feature", "source_write_signal", 2);
+  }
+  if (textMatches(text, [/\b(refactor|restructure|cleanup|rename|dedupe|simplif(y|ied))\b/i])) {
+    addSignal(scores, "refactoring", "refactor_language", 3);
+  }
+  if (files.length >= 5 && !textMatches(text, [/\b(feature|deploy|release|publish)\b/i])) {
+    addSignal(scores, "refactoring", "broad_change_without_feature_or_release_terms", 2);
+  }
+  if (sourceFiles.length >= 4 && testFiles2.length === 0) {
+    addSignal(scores, "refactoring", "many_source_files_without_tests", 1);
+  }
+  if (textMatches(text, [/\b(review|audit|inspect|triage|assessment|verdict)\b/i])) {
+    addSignal(scores, "reviewing", "review_language", 3);
+  }
+  if (actionCount(normalized, "decision") > 0) {
+    addSignal(scores, "reviewing", "decision_review_signal", 2);
+  }
+  if (textMatches(text, [/\b(policy suggestion|manual apply|required|reject|approve)\b/i])) {
+    addSignal(scores, "reviewing", "human_decision_signal", 2);
+  }
+  if (textMatches(text, [/\b(investigat(e|ing)|look into|find out|read|rg|grep|search)\b/i])) {
+    addSignal(scores, "investigating", "investigation_language", 3);
+  }
+  if (actionCount(normalized, "read") >= 2 && actionCount(normalized, "write") === 0) {
+    addSignal(scores, "investigating", "read_heavy_no_write_signal", 2);
+  }
+  if (events.length > 0 && files.length === 0) {
+    addSignal(scores, "investigating", "activity_without_file_changes", 1);
+  }
+  const ranked = PROJECT_INTENT_DETECTION_INTENTS.map((intent2) => {
+    const signals = compactSignals(scores.get(intent2) ?? []);
+    return {
+      intent: intent2,
+      signals,
+      score: signals.reduce((sum, signal) => sum + signal.weight, 0)
+    };
+  }).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return INTENT_PRIORITY[right.intent] - INTENT_PRIORITY[left.intent];
+  });
+  const best = ranked[0];
+  const intent = best.score > 0 ? best.intent : "unknown";
+  const signalDetails = best.score > 0 ? best.signals : [{ code: "insufficient_timeline_signals", intent: "unknown", weight: 0 }];
+  const confidence = confidenceFor(best.score, signalDetails.length);
+  const actionCounts = PROJECT_INTENT_DETECTION_ACTIONS.reduce((counts, action) => {
+    const count = actionCount(normalized, action);
+    if (count > 0) counts[action] = count;
+    return counts;
+  }, {});
+  const suggestedWorkflowMode = suggestedModeFor(intent, confidence, files);
+  const reasonCodes = uniqueStrings5([
+    ...signalDetails.map((signal) => signal.code),
+    `intent_${intent}`,
+    `confidence_${confidence}`
+  ]);
+  return {
+    version: INTENT_DETECTION_VERSION,
+    intent,
+    confidence,
+    signals: signalDetails.map((signal) => signal.code),
+    signalDetails,
+    reasonCodes,
+    evidence: {
+      eventCount: events.length,
+      fileCount: files.length,
+      uniqueTouchedFiles: files,
+      actionCounts
+    },
+    advisoryRouting: {
+      hardRoutingAllowed: false,
+      suggestedWorkflowMode,
+      reasonCodes,
+      caveats: [
+        "Suggested workflow mode is advisory only.",
+        "Explicit user choice, policy, and receipts are required before routing work."
+      ]
+    },
+    hardRoutingAllowed: false,
+    caveats: [
+      "Intent Detection V0 is advisory only.",
+      "It must not trigger workers, merges, canonical memory writes, or blocking gates by itself.",
+      "Confidence is heuristic and derived from local timeline evidence."
+    ]
+  };
+}
+
 // src/commands/decision-requests.ts
 var fs12 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
@@ -10469,7 +10695,7 @@ function memoryEvidenceItem(value, options) {
     summary: options.summary,
     kind: options.kind,
     status: options.status,
-    files: uniqueStrings5(evidenceRefs),
+    files: uniqueStrings6(evidenceRefs),
     metadata: compactObject({
       source: options.source,
       bucket: options.bucket,
@@ -10510,7 +10736,7 @@ function reviewQueueItems(result) {
         action: "review_queue_item",
         options: ["accept", "reject", "archive", "invalidate", "keep_pending"],
         recommendation: reviewStatus === "approved" || status === "active" ? "keep_pending" : "accept",
-        reasonCodes: uniqueStrings5(["memory_review_queue", reason ?? "", status ?? ""]),
+        reasonCodes: uniqueStrings6(["memory_review_queue", reason ?? "", status ?? ""]),
         evidenceItem: memoryEvidenceItem(item, {
           ref: `memory:${memoryId}`,
           title: `Review memory ${memoryId}`,
@@ -10549,7 +10775,7 @@ function cleanCandidateItems(result) {
         action: `${bucket}_candidate`,
         options,
         recommendation,
-        reasonCodes: uniqueStrings5(["memory_clean_candidates", bucket, reason]),
+        reasonCodes: uniqueStrings6(["memory_clean_candidates", bucket, reason]),
         evidenceItem: memoryEvidenceItem(candidate, {
           ref: `memory:${memoryId}`,
           title: `${bucket.replace(/_/g, " ")} memory candidate ${memoryId}`,
@@ -10586,7 +10812,7 @@ function duplicateCandidateItems(result) {
           action: "duplicate_candidate",
           options: ["merge", "supersede", "keep", "inspect"],
           recommendation: keepMemoryId ? "supersede" : "inspect",
-          reasonCodes: uniqueStrings5(["memory_duplicate_candidates", `group_${index + 1}`]),
+          reasonCodes: uniqueStrings6(["memory_duplicate_candidates", `group_${index + 1}`]),
           evidenceItem: memoryEvidenceItem(candidate, {
             ref: `memory:${memoryId}`,
             title: `Duplicate memory candidate ${memoryId}`,
@@ -10645,6 +10871,9 @@ async function buildMemoryReviewConnector(options) {
     items: [],
     requests: [],
     writes: [],
+    emitted: { enabled: Boolean(options.emitDecisions), count: 0, requestIds: [] },
+    emittedCount: 0,
+    emittedRequestIds: [],
     caveats: [
       "Read-only connector: hosted memory tools are queried, but no memory is mutated.",
       "Emitted decision requests must still be resolved explicitly; no timeout/default applies.",
@@ -10711,6 +10940,13 @@ async function buildMemoryReviewConnector(options) {
   result.requests = result.items.map(buildMemoryReviewDecisionRequest);
   if (options.emitDecisions) {
     result.writes = result.requests.map((request) => writeDecisionRequest(request));
+    result.emittedRequestIds = result.writes.map((write) => write.requestId);
+    result.emittedCount = result.emittedRequestIds.length;
+    result.emitted = {
+      enabled: true,
+      count: result.emittedCount,
+      requestIds: result.emittedRequestIds
+    };
   }
   return result;
 }
@@ -10806,10 +11042,10 @@ function buildMemoryAuditSummary(audit) {
     cleanupCandidateCounts,
     ...typeof compactDryRun.mutated === "boolean" ? { compactDryRunMutated: compactDryRun.mutated } : {},
     ...compactDryRunPlannedActions !== void 0 ? { compactDryRunPlannedActions } : {},
-    recommendedActions: uniqueStrings5(recommendedActions)
+    recommendedActions: uniqueStrings6(recommendedActions)
   };
 }
-function uniqueStrings5(values) {
+function uniqueStrings6(values) {
   return Array.from(new Set(values));
 }
 function printMemoryAuditSummary(summary) {
@@ -11024,7 +11260,7 @@ async function memoryAuditCommand(options) {
 var fs13 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
-function uniqueStrings6(values) {
+function uniqueStrings7(values) {
   return Array.from(new Set((values ?? []).map((value) => value.trim()).filter(Boolean)));
 }
 function slugify(value, fallback) {
@@ -11032,7 +11268,7 @@ function slugify(value, fallback) {
   return slug2 || fallback;
 }
 function keywordHints(value) {
-  return uniqueStrings6(
+  return uniqueStrings7(
     value.split(/[^A-Za-z0-9_.:/-]+/).map((part) => part.trim()).filter((part) => part.length >= 4).slice(0, 8)
   );
 }
@@ -11078,17 +11314,17 @@ function expectedItems(section, values, files) {
 }
 function buildEvalCaseArtifact(options = {}) {
   const rootDir = path12.resolve(options.dir ?? process.cwd());
-  const files = uniqueStrings6(options.files);
-  const commandsRun = uniqueStrings6(options.commandRun);
+  const files = uniqueStrings7(options.files);
+  const commandsRun = uniqueStrings7(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: uniqueStrings6(options.context),
-    decisions: uniqueStrings6(options.decision),
-    impact: uniqueStrings6(options.impact),
-    verification: uniqueStrings6(options.verification),
-    continuity: uniqueStrings6(options.continuity)
+    context: uniqueStrings7(options.context),
+    decisions: uniqueStrings7(options.decision),
+    impact: uniqueStrings7(options.impact),
+    verification: uniqueStrings7(options.verification),
+    continuity: uniqueStrings7(options.continuity)
   };
   for (const [section, values] of Object.entries(sectionInputs)) {
     if (values.length > 0) {
@@ -12550,7 +12786,7 @@ var SESSION_SNAPSHOT_VERSION = "snipara.session_snapshot.v0";
 var ACTIVITY_RELATIVE_DIR = path16.join(".snipara", "activity");
 var ACTIVITY_TIMELINE_RELATIVE_PATH = path16.join(ACTIVITY_RELATIVE_DIR, "timeline.jsonl");
 var SESSION_SNAPSHOT_RELATIVE_PATH = path16.join(ACTIVITY_RELATIVE_DIR, "session.json");
-function uniqueStrings7(values) {
+function uniqueStrings8(values) {
   return Array.from(new Set(values.map((value) => value?.trim()).filter(Boolean)));
 }
 function stableJson(value) {
@@ -12623,8 +12859,8 @@ function appendActivityEvent(input) {
     ...input.phaseId ? { phaseId: input.phaseId } : {},
     ...input.actor ? { actor: input.actor } : {},
     ...input.outcome ? { outcome: input.outcome } : {},
-    files: uniqueStrings7(input.files ?? []),
-    refs: uniqueStrings7(input.refs ?? []),
+    files: uniqueStrings8(input.files ?? []),
+    refs: uniqueStrings8(input.refs ?? []),
     metadata: input.metadata ?? {}
   };
   const timelinePath = getActivityTimelinePath(cwd);
@@ -12705,6 +12941,37 @@ function teamSyncSnapshot(cwd) {
     ...latestHandoffAt ? { latestHandoffAt } : {}
   };
 }
+function deriveSessionSnapshotSummary(args) {
+  const riskReasons = [];
+  if (args.pendingDecisionCount > 0) {
+    riskReasons.push(`${args.pendingDecisionCount} pending decision request(s)`);
+  }
+  if (args.producerLoop.unreviewedCount > 0) {
+    riskReasons.push(`${args.producerLoop.unreviewedCount} unreviewed Producer Loop artifact(s)`);
+  }
+  if (args.teamSync.activeWorkCount > 0) {
+    riskReasons.push(`${args.teamSync.activeWorkCount} active Team Sync work item(s)`);
+  }
+  if (args.workflow?.status === "blocked") {
+    riskReasons.push("workflow is blocked");
+  }
+  const touchedFiles = uniqueStrings8(args.latestEvents.flatMap((event) => event.files)).slice(
+    0,
+    20
+  );
+  const latestActivity = args.latestEvents[0];
+  const risk = riskReasons.length >= 2 ? "risk" : riskReasons.length === 1 ? "watch" : "none";
+  const recommendedNextAction = args.workflow?.status === "completed" ? "Start the next managed workflow or export the timeline for handoff." : args.workflow?.currentPhaseId ? `Continue phase ${args.workflow.currentPhaseId} or commit it when verified.` : args.pendingDecisionCount > 0 ? "Resolve pending decision requests before applying follow-up actions." : "Review the latest activity and run the next verification command.";
+  return {
+    ...latestActivity?.timestamp ? { latestActivityAt: latestActivity.timestamp } : {},
+    ...latestActivity?.title ? { latestActivityTitle: latestActivity.title } : {},
+    ...latestActivity?.kind ? { latestActivityKind: latestActivity.kind } : {},
+    risk,
+    riskReasons,
+    touchedFiles,
+    recommendedNextAction
+  };
+}
 function buildSessionSnapshot(options = {}) {
   const startedAt = Date.now();
   const cwd = options.cwd ?? process.cwd();
@@ -12712,6 +12979,9 @@ function buildSessionSnapshot(options = {}) {
   const latestEvents = events.slice(0, options.limit && options.limit > 0 ? options.limit : 20);
   const pendingDecisions = readJsonDir(path16.join(cwd, ".snipara", "decisions", "pending"));
   const resolvedDecisions = readJsonDir(path16.join(cwd, ".snipara", "decisions", "resolved"));
+  const workflow2 = workflowSnapshot(cwd);
+  const producerLoop = producerLoopSummary(cwd);
+  const teamSync2 = teamSyncSnapshot(cwd);
   const snapshot = {
     schemaVersion: SESSION_SNAPSHOT_VERSION,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12720,7 +12990,7 @@ function buildSessionSnapshot(options = {}) {
       timelinePath: getActivityTimelinePath(cwd),
       snapshotPath: getSessionSnapshotPath(cwd)
     },
-    workflow: workflowSnapshot(cwd),
+    workflow: workflow2,
     activity: {
       totalEvents: events.length,
       ...events[0]?.timestamp ? { latestEventAt: events[0].timestamp } : {},
@@ -12733,8 +13003,26 @@ function buildSessionSnapshot(options = {}) {
       resolvedCount: resolvedDecisions.length,
       recurringResolvedFingerprintCount: countDecisionFingerprintRepeats(resolvedDecisions)
     },
-    producerLoop: producerLoopSummary(cwd),
-    teamSync: teamSyncSnapshot(cwd),
+    producerLoop,
+    teamSync: teamSync2,
+    summary: deriveSessionSnapshotSummary({
+      workflow: workflow2,
+      latestEvents,
+      pendingDecisionCount: pendingDecisions.length,
+      producerLoop,
+      teamSync: teamSync2
+    }),
+    intentDetection: buildIntentDetectionFromTimeline(
+      latestEvents.map((event) => ({
+        kind: event.kind,
+        source: event.source,
+        title: event.title,
+        summary: event.summary,
+        outcome: event.outcome,
+        files: event.files,
+        metadata: event.metadata
+      }))
+    ),
     routing: {
       hardRoutingAllowed: false,
       reason: "Session Snapshot V0 is observational only; hard routing needs explicit policy and receipt gates."
@@ -12758,9 +13046,16 @@ function writeSessionSnapshot(options = {}) {
 `, "utf8");
   return snapshot;
 }
+function readSessionSnapshot(cwd = process.cwd()) {
+  const parsed = safeReadJson(getSessionSnapshotPath(cwd));
+  if (parsed?.schemaVersion === SESSION_SNAPSHOT_VERSION && parsed.summary && parsed.intentDetection) {
+    return parsed;
+  }
+  return null;
+}
 
 // src/commands/journal.ts
-function uniqueStrings8(values) {
+function uniqueStrings9(values) {
   if (!values) {
     return [];
   }
@@ -12788,7 +13083,7 @@ function buildJournalCheckpointEntry(payload) {
     payload.actor ? `Actor: ${payload.actor}` : null,
     payload.attention ? `Attention: ${payload.attention}` : null,
     payload.next ? `Next: ${payload.next}` : null,
-    uniqueStrings8(payload.files).length > 0 ? `Files: ${uniqueStrings8(payload.files).join(", ")}` : null
+    uniqueStrings9(payload.files).length > 0 ? `Files: ${uniqueStrings9(payload.files).join(", ")}` : null
   ].filter((line) => Boolean(line));
   return {
     text: lines.join("\n"),
@@ -12884,7 +13179,7 @@ function createRedactor(rootDir) {
       patterns.add(item.name);
       item.pattern.lastIndex = 0;
     }
-    const uniqueMatchedPatterns = uniqueStrings9(matchedPatterns);
+    const uniqueMatchedPatterns = uniqueStrings10(matchedPatterns);
     if (uniqueMatchedPatterns.length > 0) {
       redactedValueCount += 1;
     }
@@ -12999,14 +13294,14 @@ function buildRepoState(input, options, rootDir, redactor) {
   const inputRepo = inputRecord(input, "repoState", "repo_state", "repo");
   const detected = detectGitState(rootDir);
   const statusCounts = countGitStatus(detected.statusLines);
-  const changedFiles = uniqueStrings9([
+  const changedFiles = uniqueStrings10([
     ...normalizeUnknownStringList(inputRepo.changedFiles),
     ...normalizeUnknownStringList(inputRepo.changed_files),
     ...normalizeUnknownStringList(input.changedFiles),
     ...normalizeUnknownStringList(input.changed_files),
     ...options.changedFiles ?? []
   ]).map((item) => redactor.redact(item).value);
-  const recentFiles = uniqueStrings9([
+  const recentFiles = uniqueStrings10([
     ...normalizeUnknownStringList(inputRepo.recentFiles),
     ...normalizeUnknownStringList(inputRepo.recent_files),
     ...normalizeUnknownStringList(input.recentFiles),
@@ -13074,18 +13369,18 @@ function normalizeEvidenceItem(value, section, index, redactor) {
     "command",
     "check"
   ]) ?? fallbackSummary(value, section, index);
-  const reasonCodes = uniqueStrings9([
+  const reasonCodes = uniqueStrings10([
     `section_${section}`,
     ...normalizeUnknownStringList(value.reasonCodes),
     ...normalizeUnknownStringList(value.reason_codes)
   ]).map((item) => redactor.redact(item).value);
-  const files = uniqueStrings9([
+  const files = uniqueStrings10([
     ...normalizeUnknownStringList(value.files),
     ...normalizeUnknownStringList(value.changedFiles),
     ...normalizeUnknownStringList(value.changed_files),
     ...normalizeUnknownStringList(value.file)
   ]).slice(0, MAX_LIST_ITEMS).map((item) => redactor.redact(item).value);
-  const commands = uniqueStrings9([
+  const commands = uniqueStrings10([
     ...normalizeUnknownStringList(value.commands),
     ...normalizeUnknownStringList(value.command),
     ...normalizeUnknownStringList(value.checks),
@@ -13109,7 +13404,7 @@ function normalizeEvidenceItem(value, section, index, redactor) {
   });
 }
 function collectReasonCodes(input, cliValues, items, redactor) {
-  return uniqueStrings9([
+  return uniqueStrings10([
     "coding_intelligence_ledger_v0",
     ...normalizeUnknownStringList(input.reasonCodes),
     ...normalizeUnknownStringList(input.reason_codes),
@@ -13140,13 +13435,13 @@ function buildCalibrationMetadata(input, cliValues, redactor) {
     "calibration",
     "calibration_metadata"
   );
-  const notes = uniqueStrings9([
+  const notes = uniqueStrings10([
     ...normalizeUnknownStringList(calibration.notes),
     ...normalizeUnknownStringList(calibration.note),
     ...normalizeUnknownStringList(input.calibrationNotes),
     ...cliValues ?? []
   ]).slice(0, MAX_LIST_ITEMS).map((item) => redactor.redact(item).value);
-  const caveats = uniqueStrings9([
+  const caveats = uniqueStrings10([
     ...normalizeUnknownStringList(calibration.caveats),
     ...normalizeUnknownStringList(calibration.caveat),
     ...normalizeUnknownStringList(input.calibrationCaveats)
@@ -13343,7 +13638,7 @@ function validIso(value) {
   const date = new Date(value);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
-function uniqueStrings9(values) {
+function uniqueStrings10(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
 }
 function compactWhitespace(value) {
@@ -15254,16 +15549,16 @@ function upsertLocalAdaptiveRoutingPolicy(workerRole) {
     mode: stringValue5(existing.mode) ?? "catalog",
     plannerRetainsReasoning: existing.plannerRetainsReasoning !== false,
     preferLocalWorkers: true,
-    allowedEndpointTypes: uniqueStrings10([
+    allowedEndpointTypes: uniqueStrings11([
       ...normalizeStringList2(existing.allowedEndpointTypes),
       "local",
       "cloud"
     ]),
-    preferredEndpointTypes: uniqueStrings10([
+    preferredEndpointTypes: uniqueStrings11([
       "local",
       ...normalizeStringList2(existing.preferredEndpointTypes)
     ]),
-    allowedWorkerClasses: uniqueStrings10([
+    allowedWorkerClasses: uniqueStrings11([
       ...normalizeStringList2(existing.allowedWorkerClasses),
       workerRole,
       "documentation",
@@ -15323,9 +15618,9 @@ function defaultCapabilitiesForWorker(workerRole) {
 }
 function normalizeStringList2(value) {
   const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
-  return uniqueStrings10(values.map(stringValue5).filter((item) => Boolean(item)));
+  return uniqueStrings11(values.map(stringValue5).filter((item) => Boolean(item)));
 }
-function uniqueStrings10(values) {
+function uniqueStrings11(values) {
   return Array.from(new Set(values));
 }
 function stringValue5(value) {
@@ -15483,7 +15778,7 @@ function numberValue3(value) {
   const parsed = Number(text);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-function uniqueStrings11(values) {
+function uniqueStrings12(values) {
   return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
 }
 function normalizeEnum(value) {
@@ -16566,7 +16861,7 @@ function buildProducerLoopArtifact(options) {
     workflowId ?? "unmanaged",
     options.phase?.id ? `phase:${options.phase.id}` : "final"
   ].join(":");
-  const reasonCodes = uniqueStrings11([
+  const reasonCodes = uniqueStrings12([
     "producer_loop_v0",
     options.kind,
     `outcome_${options.outcome}`,
@@ -16758,8 +17053,8 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
         relativePath: relativePath2,
         artifactHash: `sha256:${hashContent(content)}`,
         ledgerHash: stringValue6(parsed.ledgerHash),
-        reasonCodes: uniqueStrings11(stringArrayValue(ledger?.reasonCodes)),
-        files: uniqueStrings11(stringArrayValue(producer.files)),
+        reasonCodes: uniqueStrings12(stringArrayValue(ledger?.reasonCodes)),
+        files: uniqueStrings12(stringArrayValue(producer.files)),
         calibrationStatus: stringValue6(calibration?.status),
         reviewStatus,
         reviewOutcome: stringValue6(review?.outcome),
@@ -16806,10 +17101,10 @@ function buildProducerLoopReport(options = {}) {
     (left, right) => left.generatedAt === right.generatedAt ? left.relativePath.localeCompare(right.relativePath) : left.generatedAt.localeCompare(right.generatedAt)
   );
   const invalidArtifacts = summaries.map((entry) => entry.invalid).filter((entry) => Boolean(entry));
-  const producerKinds = uniqueStrings11(artifacts.map((artifact) => artifact.producerKind)).filter(
+  const producerKinds = uniqueStrings12(artifacts.map((artifact) => artifact.producerKind)).filter(
     (kind) => isProducerLoopProducerKind(kind)
   );
-  const workflowIds = uniqueStrings11(
+  const workflowIds = uniqueStrings12(
     artifacts.map((artifact) => artifact.workflowId).filter((id) => Boolean(id))
   );
   const reasonCodeCounts = countStringOccurrences(
@@ -16960,7 +17255,7 @@ function readProducerLoopArtifactForReview(filePath) {
   return parsed;
 }
 function applyProducerLoopArtifactReview(artifact, options) {
-  const reviewNotes = uniqueStrings11(options.notes ?? []);
+  const reviewNotes = uniqueStrings12(options.notes ?? []);
   const reviewNote = options.status === "sample_rejected" ? "Sample rejected by local operator review." : "Sample reviewed by local operator.";
   const existingCalibration = artifact.calibration ?? {
     status: "sample_unreviewed",
@@ -16975,7 +17270,7 @@ function applyProducerLoopArtifactReview(artifact, options) {
       status: options.status,
       sampleSize: 1,
       hardGateReady: false,
-      notes: uniqueStrings11([
+      notes: uniqueStrings12([
         ...stringArrayValue(existingCalibration.notes),
         reviewNote,
         ...reviewNotes.map((note) => `Review note: ${note}`)
@@ -17185,7 +17480,7 @@ function applyDecisionRequestLocally(options) {
       reject: isRejectChoice(options.choice),
       outcome: isRejectChoice(options.choice) ? "false_positive" : "useful",
       reviewer: options.reviewer,
-      notes: uniqueStrings11([
+      notes: uniqueStrings12([
         `decision_request:${request.requestId}`,
         ...options.note ? [options.note] : []
       ])
@@ -17199,12 +17494,17 @@ function applyDecisionRequestLocally(options) {
 function recurringPolicySuggestionKey(record) {
   return stableDecisionJsonStringify({
     producer: record.request.producer.kind,
-    decision: record.request.decision,
     choice: record.response.choice,
-    note: compactWhitespace2(record.response.note ?? "").toLowerCase(),
-    reasonCodes: record.request.evidence.reasonCodes
+    targetCategory: recurringPolicySuggestionTargetCategory(record.request)
   });
 }
+function recurringPolicySuggestionTargetCategory(request) {
+  const evidenceCategories = request.evidence.items?.map((item) => {
+    const metadata = isRecord8(item.metadata) ? item.metadata : void 0;
+    return stringValue6(metadata?.category) ?? stringValue6(metadata?.type) ?? item.kind;
+  }).filter((value) => Boolean(value)) ?? [];
+  return uniqueStrings12(evidenceCategories).sort().join("|") || request.evidence.applyPath || request.decision;
+}
 function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
   const grouped = /* @__PURE__ */ new Map();
   for (const record of resolvedRecords) {
@@ -17221,6 +17521,7 @@ function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
   const refs = repeated.map((record) => record.request.requestId);
   const note = compactWhitespace2(latest.response.note ?? "");
   const policyTitle = note ? `Never ask twice for: ${note}` : `Never ask twice for ${latest.request.decision} -> ${latest.response.choice}`;
+  const targetCategory = recurringPolicySuggestionTargetCategory(latest.request);
   return buildDecisionRequest({
     producer: {
       kind: "policy_suggestion",
@@ -17240,12 +17541,12 @@ function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
         status: record.response.choice,
         files: record.request.evidence.files?.slice(0, 12)
       })),
-      reasonCodes: uniqueStrings11([
+      reasonCodes: uniqueStrings12([
         "recurring_decision_receipts",
         "never_ask_twice_candidate",
         ...latest.request.evidence.reasonCodes
       ]),
-      files: uniqueStrings11(repeated.flatMap((record) => record.request.evidence.files ?? [])),
+      files: uniqueStrings12(repeated.flatMap((record) => record.request.evidence.files ?? [])),
       applyPath: "manual_context_review",
       applyCommand: "Review the suggested rule and add it to the appropriate project policy or AGENTS.md section manually."
     },
@@ -17255,10 +17556,9 @@ function buildRecurringDecisionPolicySuggestionRequest(resolvedRecords) {
     fingerprintParts: [
       "recurring_decision_policy_suggestion",
       repeated.length,
-      latest.request.decision,
+      latest.request.producer.kind,
       latest.response.choice,
-      compactWhitespace2(latest.response.note ?? "").toLowerCase(),
-      latest.request.evidence.reasonCodes
+      targetCategory
     ]
   });
 }
@@ -17388,12 +17688,12 @@ function buildProducerTriageRequest(report) {
       summary: `${candidates.length} unreviewed Producer Loop samples; ${report.invalidArtifacts.length} invalid artifacts; hardGateReady remains false.`,
       refs,
       items,
-      reasonCodes: uniqueStrings11([
+      reasonCodes: uniqueStrings12([
         "triage_rules_v0",
         "producer_loop_report_valid",
         ...report.invalidArtifacts.length === 0 ? ["no_invalid_artifacts"] : ["invalid_artifacts_present"]
       ]),
-      files: uniqueStrings11(candidates.flatMap((artifact) => artifact.files)),
+      files: uniqueStrings12(candidates.flatMap((artifact) => artifact.files)),
       applyPath: "workflow producer-review",
       applyCommand: "snipara-companion workflow decide <request-id> --choose accept_all --reviewer <name>"
     },
@@ -17454,7 +17754,7 @@ async function workflowDecisionProducerMemoryCommand(options) {
     const request2 = buildMemoryReviewDecisionRequest({
       ...reviewItem,
       action,
-      recommendation: options.reviewerHint ?? reviewItem.recommendation,
+      recommendation: options.reviewerHint ?? action,
       options: action === "verify" ? ["verify", "keep_pending", "invalidate"] : action === "invalidate" ? ["invalidate", "keep", "inspect"] : reviewItem.options.includes(action) ? reviewItem.options : [action, ...reviewItem.options.filter((option) => option !== action)]
     });
     const write2 = writeDecisionRequest(request2);
@@ -19114,8 +19414,8 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       runtimeCatalog: catalog,
       routingCard: {
         ...routing.routingCard,
-        reasons: uniqueStrings11(reasons),
-        warnings: uniqueStrings11([...routing.routingCard.warnings, ...gatewayWarnings])
+        reasons: uniqueStrings12(reasons),
+        warnings: uniqueStrings12([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -19132,7 +19432,7 @@ async function enrichAdaptiveRoutingWithHostedCatalog(client, routing) {
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings11([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings12([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -19298,7 +19598,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
     const approvalRequired = booleanValue3(
       isRecord8(resolution?.policyDecision) ? resolution.policyDecision.approvalRequired : void 0
     );
-    const gatewayWarnings = uniqueStrings11([
+    const gatewayWarnings = uniqueStrings12([
       ...resolutionWarnings,
       ...selectedCandidate ? [] : ["Local orchestrator did not select a worker candidate and will fail closed."]
     ]);
@@ -19319,7 +19619,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
         ...routing.routingCard,
         ...selectedCandidate?.workerClass ? { recommendedWorkerClass: selectedCandidate.workerClass } : {},
         ...approvalRequired !== void 0 ? { humanApprovalRequired: approvalRequired } : {},
-        reasons: uniqueStrings11([
+        reasons: uniqueStrings12([
           ...routing.routingCard.reasons,
           ...resolutionReasons,
           ...selectedCandidate ? [
@@ -19328,7 +19628,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
             ...stringValue6(selectedEndpoint?.model) ? [`selected local model ${String(selectedEndpoint?.model)}`] : []
           ] : ["local orchestrator could not resolve a concrete worker candidate"]
         ]),
-        warnings: uniqueStrings11([...routing.routingCard.warnings, ...gatewayWarnings])
+        warnings: uniqueStrings12([...routing.routingCard.warnings, ...gatewayWarnings])
       }
     };
   } catch (error) {
@@ -19345,7 +19645,7 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
       },
       routingCard: {
         ...routing.routingCard,
-        warnings: uniqueStrings11([...routing.routingCard.warnings, warning])
+        warnings: uniqueStrings12([...routing.routingCard.warnings, warning])
       }
     };
   }
@@ -20215,7 +20515,7 @@ function scanOnboardFolder(options) {
   files.sort((a, b) => a.path.localeCompare(b.path));
   return files;
 }
-function addSignal(signals, signal) {
+function addSignal2(signals, signal) {
   if (!signals.includes(signal)) {
     signals.push(signal);
   }
@@ -20229,7 +20529,7 @@ function classifyOnboardFolder(rootDir, files, overrideMode = "auto") {
   let supportedPlainDocuments = 0;
   if (fs21.existsSync(path20.join(rootDir, ".git"))) {
     codeScore += 4;
-    addSignal(codeSignals, ".git directory");
+    addSignal2(codeSignals, ".git directory");
   }
   for (const file of files) {
     const base = path20.basename(file.path);
@@ -20237,22 +20537,22 @@ function classifyOnboardFolder(rootDir, files, overrideMode = "auto") {
     const firstSegment = firstPathSegment(file.path);
     if (CODE_MARKER_FILES.has(base)) {
       codeScore += 3;
-      addSignal(codeSignals, base);
+      addSignal2(codeSignals, base);
     }
     if (CODE_MARKER_DIRS.has(firstSegment)) {
       codeScore += 1.5;
-      addSignal(codeSignals, `${firstSegment}/ directory`);
+      addSignal2(codeSignals, `${firstSegment}/ directory`);
     }
     if (CODE_SOURCE_EXTENSIONS.has(ext)) {
       codeSourceFiles += 1;
     }
     if ([".docx", ".pdf", ".pptx", ".vsdx", ".xlsx", ".xls", ".csv", ".tsv"].includes(ext)) {
       businessScore += 2;
-      addSignal(businessSignals, `${ext} documents`);
+      addSignal2(businessSignals, `${ext} documents`);
     }
     if (hasBusinessKeyword(file.path)) {
       businessScore += 2;
-      addSignal(businessSignals, `business keyword in ${file.path}`);
+      addSignal2(businessSignals, `business keyword in ${file.path}`);
     }
     if (file.supported && [".md", ".markdown", ".mdx", ".txt", ".rst", ".adoc"].includes(ext)) {
       supportedPlainDocuments += 1;
@@ -20261,10 +20561,10 @@ function classifyOnboardFolder(rootDir, files, overrideMode = "auto") {
   codeScore += Math.min(5, codeSourceFiles * 0.25);
   businessScore += Math.min(3, supportedPlainDocuments * 0.35);
   if (codeSourceFiles > 0) {
-    addSignal(codeSignals, `${codeSourceFiles} source-looking files`);
+    addSignal2(codeSignals, `${codeSourceFiles} source-looking files`);
   }
   if (supportedPlainDocuments > 0) {
-    addSignal(businessSignals, `${supportedPlainDocuments} supported text documents`);
+    addSignal2(businessSignals, `${supportedPlainDocuments} supported text documents`);
   }
   const codeStrong = codeScore >= 3;
   const businessStrong = businessScore >= 2.5 || !codeStrong && files.some((file) => file.supported);
@@ -21148,8 +21448,8 @@ function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = [
     ...routing,
     routingCard: {
       ...routing.routingCard,
-      reasons: uniqueStrings11([...routing.routingCard.reasons, ...policyReasons]),
-      warnings: uniqueStrings11([...routing.routingCard.warnings, ...policyWarnings])
+      reasons: uniqueStrings12([...routing.routingCard.reasons, ...policyReasons]),
+      warnings: uniqueStrings12([...routing.routingCard.warnings, ...policyWarnings])
     }
   };
 }
@@ -21165,7 +21465,7 @@ function normalizeAdaptiveRoutingMode(value) {
   return normalized === "off" || normalized === "recommend" || normalized === "catalog" ? normalized : null;
 }
 function normalizeAdaptiveWorkerClasses(values) {
-  return uniqueStrings11((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
+  return uniqueStrings12((values ?? []).map(canonicalAdaptiveWorkerClass)).filter(
     (value) => ["documentation", "tests", "review", "coding"].includes(value)
   );
 }
@@ -21601,12 +21901,80 @@ function printAgenticTimeline(timeline) {
   }
   console.log("");
 }
+function escapeRegExp5(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function localWorkspacePathAliases() {
+  const cwd = process.cwd();
+  const aliases = /* @__PURE__ */ new Set([cwd]);
+  try {
+    aliases.add(fs21.realpathSync(cwd));
+  } catch {
+  }
+  for (const alias of [...aliases]) {
+    if (alias.startsWith("/private/var/")) aliases.add(alias.replace(/^\/private/, ""));
+    else if (alias.startsWith("/var/")) aliases.add(`/private${alias}`);
+  }
+  return [...aliases].filter(Boolean).sort((left, right) => right.length - left.length);
+}
+function redactTimelineText(value, maxLength = 180) {
+  let text = toPreview(value, maxLength);
+  for (const alias of localWorkspacePathAliases()) {
+    text = text.replace(new RegExp(escapeRegExp5(alias), "g"), "[workspace]");
+  }
+  return text.replace(/\/Users\/[^/\s)]+/g, "[home]").replace(/\.snipara\/[^\s,)]+/g, "[local-state]").replace(/\b(api[_-]?key|token|secret|password)=\S+/gi, "$1=[redacted]");
+}
+function redactTimelineFile(file) {
+  const workspaceAlias = localWorkspacePathAliases().find(
+    (alias) => path20.isAbsolute(file) && file.startsWith(alias)
+  );
+  const relative8 = workspaceAlias ? path20.relative(workspaceAlias, file) : file;
+  if (relative8.startsWith(".snipara/") || relative8 === ".snipara") {
+    return "[local-state]";
+  }
+  return redactTimelineText(relative8, 120);
+}
+function formatAgenticTimelineMarkdown(timeline) {
+  const lines = [
+    "# Workflow Timeline",
+    "",
+    `Generated: ${timeline.generatedAt}`,
+    `Events: ${timeline.events.length}`,
+    "",
+    "> Redacted local export. Absolute paths, local state paths, and secret-like fragments are removed.",
+    ""
+  ];
+  for (const event of timeline.events) {
+    lines.push(`## ${redactTimelineText(event.time, 40)} - ${redactTimelineText(event.kind, 80)}`);
+    lines.push("");
+    lines.push(`- Source: ${redactTimelineText(event.source, 80)}`);
+    lines.push(`- Title: ${redactTimelineText(event.title, 180)}`);
+    if (event.detail) {
+      lines.push(`- Summary: ${redactTimelineText(event.detail, 220)}`);
+    }
+    if (event.files?.length) {
+      lines.push(
+        `- Files: ${event.files.slice(0, 6).map(redactTimelineFile).join(", ")}${event.files.length > 6 ? ` (+${event.files.length - 6})` : ""}`
+      );
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
 async function workflowTimelineCommand(options) {
   const timeline = buildAgenticTimeline({ limit: options.limit });
   if (options.json) {
     printJson2(timeline);
     return;
   }
+  if (options.exportFormat) {
+    if (options.exportFormat !== "md") {
+      throw new Error("Unsupported workflow timeline export format. Use --export md.");
+    }
+    process.stdout.write(formatAgenticTimelineMarkdown(timeline));
+    return;
+  }
   printAgenticTimeline(timeline);
 }
 async function workflowSessionCommand(options) {
@@ -21638,6 +22006,17 @@ async function workflowSessionCommand(options) {
   printKeyValue2("Resolved decisions:", snapshot.decisions.resolvedCount);
   printKeyValue2("Producer artifacts:", snapshot.producerLoop.artifactCount);
   printKeyValue2("Team Sync active work:", snapshot.teamSync.activeWorkCount);
+  printKeyValue2(
+    "Intent:",
+    `${snapshot.intentDetection.intent} (${snapshot.intentDetection.confidence})`
+  );
+  printKeyValue2(
+    "Suggested mode:",
+    `${snapshot.intentDetection.advisoryRouting.suggestedWorkflowMode} (advisory)`
+  );
+  if (snapshot.intentDetection.signals.length > 0) {
+    console.log(`Intent signals: ${snapshot.intentDetection.signals.slice(0, 5).join(", ")}`);
+  }
   printKeyValue2("Hard routing allowed:", String(snapshot.routing.hardRoutingAllowed));
   console.log(`Reason: ${snapshot.routing.reason}`);
   printKeyValue2("Snapshot:", snapshot.source.snapshotPath);
@@ -21864,10 +22243,12 @@ async function workflowResumeCommand(options) {
   });
   const teamSyncResume = await loadWorkflowTeamSyncResume(state);
   const runtimeResume = await loadWorkflowRuntimeResumePlan(state);
+  const localSessionSnapshot = writeSessionSnapshot({ limit: 8 });
   if (options.json) {
     printJson2({
       workflow: state,
       pending_decision_count: safeDecisionPendingCount(),
+      local_session_snapshot: localSessionSnapshot,
       session_bootstrap: bootstrap,
       session_bootstrap_quality: bootstrapQuality,
       team_sync_resume: teamSyncResume?.data ?? null,
@@ -21887,6 +22268,7 @@ async function workflowResumeCommand(options) {
     includeSessionContext: resolvedContextTokens > 0
   });
   printSessionBootstrapQuality(bootstrapQuality);
+  printWorkflowLocalSessionSnapshot(localSessionSnapshot);
   printWorkflowTeamSyncResume(teamSyncResume);
   printWorkflowRuntimeResumePlan(runtimeResume);
   printManagedWorkflowResumeBoundary();
@@ -21914,6 +22296,37 @@ async function loadWorkflowTeamSyncResume(state) {
     };
   }
 }
+function printWorkflowLocalSessionSnapshot(snapshot) {
+  console.log("");
+  console.log(import_chalk6.default.bold("Local Session Snapshot"));
+  if (snapshot.summary.latestActivityAt) {
+    printKeyValue2("Latest activity:", snapshot.summary.latestActivityAt);
+  }
+  if (snapshot.summary.latestActivityTitle) {
+    printKeyValue2("Latest title:", toPreview(snapshot.summary.latestActivityTitle, 160));
+  }
+  printKeyValue2("Risk:", snapshot.summary.risk);
+  if (snapshot.summary.riskReasons.length > 0) {
+    console.log(`Risk reasons: ${snapshot.summary.riskReasons.slice(0, 3).join("; ")}`);
+  }
+  if (snapshot.summary.touchedFiles.length > 0) {
+    console.log(`Touched files: ${snapshot.summary.touchedFiles.slice(0, 8).join(", ")}`);
+  }
+  printKeyValue2(
+    "Intent:",
+    `${snapshot.intentDetection.intent} (${snapshot.intentDetection.confidence})`
+  );
+  printKeyValue2(
+    "Suggested mode:",
+    `${snapshot.intentDetection.advisoryRouting.suggestedWorkflowMode} (advisory)`
+  );
+  if (snapshot.intentDetection.signals.length > 0) {
+    console.log(`Intent signals: ${snapshot.intentDetection.signals.slice(0, 5).join(", ")}`);
+  }
+  printKeyValue2("Hard routing allowed:", String(snapshot.intentDetection.hardRoutingAllowed));
+  printKeyValue2("Next action:", snapshot.summary.recommendedNextAction);
+  printKeyValue2("Snapshot:", snapshot.source.snapshotPath);
+}
 function printWorkflowTeamSyncResume(result) {
   if (!result) {
     return;
@@ -25262,7 +25675,7 @@ function normalizeCaptureEvent(event, now, index) {
   const reasons = normalizeStringList3(event.reason).map(redactText);
   const evidence = normalizeStringList3(event.evidence).map(redactText);
   const commands = normalizeStringList3(event.commands).map(redactText);
-  const redactionPatterns = uniqueStrings12([
+  const redactionPatterns = uniqueStrings13([
     ...summary.patterns,
     ...outcome.patterns,
     ...status.patterns,
@@ -25295,7 +25708,7 @@ function normalizeEventKind(value) {
   return "feedback";
 }
 function reasonCodesForEvent(event, kind, status) {
-  return uniqueStrings12([
+  return uniqueStrings13([
     "why_outcome_capture_v1",
     "review_pending_authority",
     `source_${event.kind}`,
@@ -25360,7 +25773,7 @@ function readEventsFromFile(filePath) {
 function stableHash2(parts) {
   return (0, import_node_crypto7.createHash)("sha256").update(parts.join("\0")).digest("hex");
 }
-function uniqueStrings12(values) {
+function uniqueStrings13(values) {
   return Array.from(new Set(values.filter(Boolean)));
 }
 function compactWhitespace3(value) {
@@ -26652,6 +27065,14 @@ async function buildProjectIntelligenceBrief(options) {
       diffSummary: options.diffSummary
     })
   };
+  try {
+    brief.localSessionSnapshot = readSessionSnapshot() ?? buildSessionSnapshot({ limit: 8 });
+  } catch (error) {
+    errors.push({
+      surface: "local_session_snapshot",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
   try {
     brief.resumeContext = await client.callTool("snipara_resume_context", {
       ...branch ? { branch } : {},
@@ -26750,6 +27171,36 @@ function printResumeContext(result) {
     }
   }
 }
+function printLocalSessionSnapshot(snapshot) {
+  if (!snapshot) {
+    console.log(import_chalk9.default.yellow("Unavailable"));
+    return;
+  }
+  if (snapshot.summary.latestActivityAt) {
+    console.log(`Latest activity: ${snapshot.summary.latestActivityAt}`);
+  }
+  if (snapshot.summary.latestActivityTitle) {
+    console.log(`Latest title: ${preview3(snapshot.summary.latestActivityTitle, 220)}`);
+  }
+  console.log(`Risk: ${snapshot.summary.risk}`);
+  if (snapshot.summary.riskReasons.length > 0) {
+    console.log(`Risk reasons: ${snapshot.summary.riskReasons.slice(0, 3).join("; ")}`);
+  }
+  if (snapshot.summary.touchedFiles.length > 0) {
+    console.log(`Touched files: ${snapshot.summary.touchedFiles.slice(0, 8).join(", ")}`);
+  }
+  console.log(
+    `Intent: ${snapshot.intentDetection.intent} (${snapshot.intentDetection.confidence})`
+  );
+  console.log(
+    `Suggested mode: ${snapshot.intentDetection.advisoryRouting.suggestedWorkflowMode} (advisory)`
+  );
+  if (snapshot.intentDetection.signals.length > 0) {
+    console.log(`Intent signals: ${snapshot.intentDetection.signals.slice(0, 5).join(", ")}`);
+  }
+  console.log(`Hard routing allowed: ${snapshot.intentDetection.hardRoutingAllowed}`);
+  console.log(`Next action: ${snapshot.summary.recommendedNextAction}`);
+}
 function printMemoryHealth2(result) {
   if (!result) {
     console.log(import_chalk9.default.yellow("Skipped or unavailable"));
@@ -26824,6 +27275,9 @@ async function projectIntelligenceBriefCommand(options) {
   console.log(import_chalk9.default.bold("Continuity"));
   printResumeContext(brief.resumeContext);
   console.log("");
+  console.log(import_chalk9.default.bold("Local Session"));
+  printLocalSessionSnapshot(brief.localSessionSnapshot);
+  console.log("");
   console.log(import_chalk9.default.bold("Memory Authority And Health"));
   printMemoryHealth2(brief.memoryHealth);
   console.log("");
@@ -29531,7 +29985,7 @@ function mergeManagedCollaborationHookBlock(hookName, currentContent, block) {
   const startMarker = collaborationHookBlockMarker(hookName, "start");
   const endMarker = collaborationHookBlockMarker(hookName, "end");
   const managedBlockPattern = new RegExp(
-    `${escapeRegExp5(startMarker)}[\\s\\S]*?${escapeRegExp5(endMarker)}\\n?`,
+    `${escapeRegExp6(startMarker)}[\\s\\S]*?${escapeRegExp6(endMarker)}\\n?`,
     "m"
   );
   const base = currentContent && currentContent.trim() ? currentContent : "#!/usr/bin/env sh\n";
@@ -30077,7 +30531,7 @@ function safeUsername() {
 function formatError2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function escapeRegExp5(value) {
+function escapeRegExp6(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function ensureTrailingNewline3(value) {
@@ -31151,9 +31605,10 @@ workflow.command("start").description(
 workflow.command("status").description("Show the current local Snipara workflow state").option("--json", "Print raw JSON").action(async (options) => {
   await workflowStatusCommand({ json: options.json });
 });
-workflow.command("timeline").description("Show the append-only local activity timeline for this workflow session").option("-l, --limit <number>", "Maximum number of events", "20").option("--json", "Print raw JSON").action(async (options) => {
+workflow.command("timeline").description("Show the append-only local activity timeline for this workflow session").option("-l, --limit <number>", "Maximum number of events", "20").option("--export <format>", "Export redacted timeline artifact (md)").option("--json", "Print raw JSON").action(async (options) => {
   await workflowTimelineCommand({
     limit: parseInt(options.limit, 10),
+    exportFormat: options.export,
     json: Boolean(options.json)
   });
 });
@@ -32353,6 +32808,7 @@ if (require.main === module) {
   readLocalCodePromotionState,
   readLocalSourceSnapshot,
   readLocalWorkersConfig,
+  readSessionSnapshot,
   realityCheckCommand,
   referencesIngestCommand,
   referencesScanCommand,

package/docs/FULL_REFERENCE.md

@@ -177,6 +177,7 @@ snipara-companion brief --task "ship auth hardening" --changed-files src/auth.ts
 snipara-companion reality-check --task "ship auth hardening" --changed-files src/auth.ts --enforce
 snipara-companion timeline
 snipara-companion workflow timeline
+snipara-companion workflow timeline --export md
 snipara-companion workflow session --json
 snipara-companion workflow phase-commit build --summary "tests green"
 snipara-companion workflow impact-gate
@@ -218,11 +219,15 @@ snipara-companion workflow resume --include-session-context
   commits, final commits, and Team Sync handoffs.
 - `workflow timeline` reads the append-only local activity log at
   `.snipara/activity/timeline.jsonl`, enriched by workflow, Producer Loop,
-  Decision Request, Team Sync, and journal-adjacent events.
+  Decision Request, Team Sync, and journal-adjacent events. Add `--export md`
+  for a compact redacted Markdown artifact suitable for handoff or publication.
 - `workflow session` writes `.snipara/activity/session.json`, a fast Session
-  Snapshot V0 for local resume and Orchestrator dogfood. It is observational
-  only and reports `hardRoutingAllowed=false` until explicit policy and receipts
-  allow harder routing.
+  Snapshot V0 for local resume and Orchestrator dogfood. It includes latest
+  activity, risk reasons, touched files, next action, and advisory Intent
+  Detection V0. Intent Detection V0 reports intent, confidence, evidence
+  counts, reason-code signals, and an advisory suggested workflow mode. It is
+  observational only and reports `hardRoutingAllowed=false` until explicit
+  policy and receipts allow harder routing.
 - `workflow impact-gate` audits committed local workflow phases that are ahead
   of upstream but not pushed. It does not push, and dirty working-tree files are
   reported separately from the committed diff.
@@ -244,6 +249,8 @@ snipara-companion workflow resume --include-session-context
 - `memory reviews --scope project --emit-decisions` reads hosted memory review
   queue, clean-candidate, and duplicate-candidate surfaces, summarizes each item,
   and writes local Decision Request artifacts without mutating hosted memory.
+  JSON output includes `emittedCount`, `emittedRequestIds`, and an `emitted`
+  summary for direct agent follow-up.
 - `workflow producer-report` scans local Producer Loop artifacts emitted by
   workflow phase/final commits or exported PR Answer Pack decision-capture
   producers, then reports adoption, producer kinds, workflow ids, reason-code
@@ -1101,10 +1108,10 @@ Semantics:
 - `snipara-companion brief` = short alias for `snipara-companion intelligence brief`
 - `snipara-companion reality-check` = local Project Reality Check plus Intent Ledger and Unknown Registry coverage for supplied or Git-derived changed files; `--enforce` is an opt-in strict mode for calibrated hooks
 - `snipara-companion timeline` = local timeline of workflow starts, phase starts, phase commits, final commits, and Team Sync handoffs
-- `snipara-companion workflow timeline` = append-only activity timeline from `.snipara/activity/timeline.jsonl`, including workflow, Producer Loop, Decision Request, and Team Sync events emitted by Companion commands
-- `snipara-companion workflow session` = writes and prints Session Snapshot V0 at `.snipara/activity/session.json` with workflow/session counts, Producer Loop calibration, decision counts, Team Sync counts, and `hardRoutingAllowed=false`
+- `snipara-companion workflow timeline` = append-only activity timeline from `.snipara/activity/timeline.jsonl`, including workflow, Producer Loop, Decision Request, and Team Sync events emitted by Companion commands; add `--export md` for a redacted Markdown artifact
+- `snipara-companion workflow session` = writes and prints Session Snapshot V0 at `.snipara/activity/session.json` with latest activity, risk, touched files, next action, advisory Intent Detection V0 intent/confidence/signals/suggested mode, workflow/session counts, Producer Loop calibration, decision counts, Team Sync counts, and `hardRoutingAllowed=false`
 - `snipara-companion handoff` = top-level agent-ready Markdown/JSON handoff artifact plus the same local/hosted Team Sync handoff persistence
-- `snipara-companion intelligence brief` = one local Project Intelligence brief that combines resume context, memory health, and code impact for a task
+- `snipara-companion intelligence brief` = one local Project Intelligence brief that combines local Session Snapshot, hosted resume context, memory health, and code impact for a task
 - `snipara-companion intelligence reality-check` = Project Intelligence namespace alias for the same local Reality Check gate
 - `snipara-companion intelligence ledger-export` = structured redacted Coding Intelligence Ledger JSON for replay, review, and commercial proof assets without dumping raw transcripts
 - `snipara-companion run` = production Project Intelligence flow that combines the brief, guard action cards, package review, verification hints, and a final weighted Judgment Card

package/package.json

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