gitmem-mcp 1.3.1 → 1.3.2

package/CLAUDE.md.template

@@ -45,6 +45,7 @@ A PreToolUse hook blocks consequential actions until all recalled scars are conf
 | `create_decision` | Log an architectural or operational decision with rationale |
 | `list_threads` | See unresolved work carrying over between sessions |
 | `create_thread` | Track something that needs follow-up in a future session |
+| `contribute_feedback` | Report bugs, friction, or feature requests about gitmem itself |
 | `help` | Show all available commands |
 
 ## Session end
@@ -80,7 +81,7 @@ On "closing", "done for now", or "wrapping up":
      "task_completion": {
        "questions_displayed_at": "ISO timestamp (when reflection started)",
        "reflection_completed_at": "ISO timestamp (when payload written)",
-       "human_asked_at": "ISO timestamp (when 'Corrections?' shown)",
+       "human_asked_at": "ISO timestamp (when closing prompt shown)",
        "human_response_at": "ISO timestamp (when human replied)",
        "human_response": "user's correction text or 'none'"
      },
@@ -98,7 +99,7 @@ On "closing", "done for now", or "wrapping up":
    Key lesson: [one-sentence from Q7]
    ```
 
-3. **Ask**: "Corrections?" — wait for response, then call `session_close`.
+3. **Ask**: "Anything to add before I close this session?" — wait for response, then call `session_close`.
 
 4. **Call `session_close`** with `session_id` and `close_type: "standard"`.
 

package/bin/init-wizard.js

@@ -439,7 +439,7 @@ async function stepMemoryStore() {
   // Config
   const configPath = join(gitmemDir, "config.json");
   if (!existsSync(configPath)) {
-    const config = {};
+    const config = { feedback_enabled: false, telemetry_enabled: false };
     if (projectName) config.project = projectName;
     writeJson(configPath, config);
   } else if (projectName) {
@@ -849,6 +849,54 @@ async function stepGitignore() {
   return { done: true };
 }
 
+async function stepFeedbackOptIn() {
+  const configPath = join(gitmemDir, "config.json");
+  const config = readJson(configPath) || {};
+
+  // Already opted in — skip
+  if (config.feedback_enabled === true) {
+    log(CHECK, "Feedback sharing already enabled");
+    return { done: false };
+  }
+
+  // Non-interactive default install: show what's off and move on
+  if (!interactive && autoYes) {
+    log(CHECK,
+      "Anonymous feedback sharing is off",
+      "Run with --interactive to enable, or set feedback_enabled in .gitmem/config.json"
+    );
+    return { done: false };
+  }
+
+  // Ask the user
+  const accepted = await confirm(
+    "Help improve gitmem by sharing anonymous feedback? (no code, no content — just tool friction reports)",
+    false  // default No
+  );
+
+  if (!accepted) {
+    log(CHECK,
+      "Anonymous feedback sharing is off",
+      "You can enable it later in .gitmem/config.json"
+    );
+    return { done: false };
+  }
+
+  if (dryRun) {
+    log(CHECK, "Would enable feedback sharing in config.json", "[dry-run]");
+    return { done: true };
+  }
+
+  config.feedback_enabled = true;
+  writeJson(configPath, config);
+
+  log(CHECK,
+    "Anonymous feedback sharing enabled",
+    "Agents can report friction \u2014 no code or content is ever sent"
+  );
+  return { done: true };
+}
+
 // ── Main ──
 
 async function main() {
@@ -902,6 +950,9 @@ async function main() {
   const r6 = await stepGitignore();
   if (r6.done) configured++;
 
+  const r7 = await stepFeedbackOptIn();
+  if (r7.done) configured++;
+
   // ── Footer ──
   if (dryRun) {
     console.log(`${C.dim}Dry run complete \u2014 no files were modified.${C.reset}`);

package/copilot-instructions.template

@@ -75,7 +75,7 @@ Safe alternatives: `env | grep -c VARNAME` (count only), `[ -n "$VARNAME" ] && e
      "task_completion": {
        "questions_displayed_at": "ISO timestamp (when reflection started)",
        "reflection_completed_at": "ISO timestamp (when payload written)",
-       "human_asked_at": "ISO timestamp (when 'Corrections?' shown)",
+       "human_asked_at": "ISO timestamp (when closing prompt shown)",
        "human_response_at": "ISO timestamp (when human replied)",
        "human_response": "user's correction text or 'none'"
      },
@@ -93,7 +93,7 @@ Safe alternatives: `env | grep -c VARNAME` (count only), `[ -n "$VARNAME" ] && e
    Key lesson: [one-sentence from Q7]
    ```
 
-3. **Ask**: "Corrections?" — wait for response, then call `session_close`.
+3. **Ask**: "Anything to add before I close this session?" — wait for response, then call `session_close`.
 
 4. **Call `session_close`** with `session_id` and `close_type: "standard"`.
 

package/cursorrules.template

@@ -75,7 +75,7 @@ On "closing", "done for now", or "wrapping up":
      "task_completion": {
        "questions_displayed_at": "ISO timestamp (when reflection started)",
        "reflection_completed_at": "ISO timestamp (when payload written)",
-       "human_asked_at": "ISO timestamp (when 'Corrections?' shown)",
+       "human_asked_at": "ISO timestamp (when closing prompt shown)",
        "human_response_at": "ISO timestamp (when human replied)",
        "human_response": "user's correction text or 'none'"
      },
@@ -93,7 +93,7 @@ On "closing", "done for now", or "wrapping up":
    Key lesson: [one-sentence from Q7]
    ```
 
-3. **Ask**: "Corrections?" — wait for response, then call `session_close`.
+3. **Ask**: "Anything to add before I close this session?" — wait for response, then call `session_close`.
 
 4. **Call `session_close`** with `session_id` and `close_type: "standard"`.
 

package/dist/schemas/contribute-feedback.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Zod schema for contribute_feedback tool parameters
+ */
+import { z } from "zod";
+export declare const FeedbackTypeSchema: z.ZodEnum<["feature_request", "bug_report", "friction", "suggestion"]>;
+export declare const FeedbackSeveritySchema: z.ZodEnum<["low", "medium", "high"]>;
+export declare const ContributeFeedbackParamsSchema: z.ZodObject<{
+    type: z.ZodEnum<["feature_request", "bug_report", "friction", "suggestion"]>;
+    tool: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<["low", "medium", "high"]>;
+    suggested_fix: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    severity: "high" | "medium" | "low";
+    type: "suggestion" | "feature_request" | "bug_report" | "friction";
+    tool: string;
+    suggested_fix?: string | undefined;
+    context?: string | undefined;
+}, {
+    description: string;
+    severity: "high" | "medium" | "low";
+    type: "suggestion" | "feature_request" | "bug_report" | "friction";
+    tool: string;
+    suggested_fix?: string | undefined;
+    context?: string | undefined;
+}>;
+export type ContributeFeedbackParams = z.infer<typeof ContributeFeedbackParamsSchema>;
+/**
+ * Validate contribute_feedback params
+ */
+export declare function validateContributeFeedbackParams(params: unknown): {
+    success: boolean;
+    data?: ContributeFeedbackParams;
+    error?: string;
+};
+//# sourceMappingURL=contribute-feedback.d.ts.map

package/dist/schemas/contribute-feedback.js

@@ -0,0 +1,26 @@
+/**
+ * Zod schema for contribute_feedback tool parameters
+ */
+import { z } from "zod";
+export const FeedbackTypeSchema = z.enum(["feature_request", "bug_report", "friction", "suggestion"]);
+export const FeedbackSeveritySchema = z.enum(["low", "medium", "high"]);
+export const ContributeFeedbackParamsSchema = z.object({
+    type: FeedbackTypeSchema,
+    tool: z.string().min(1).max(100),
+    description: z.string().min(20).max(2000),
+    severity: FeedbackSeveritySchema,
+    suggested_fix: z.string().max(1000).optional(),
+    context: z.string().max(500).optional(),
+});
+/**
+ * Validate contribute_feedback params
+ */
+export function validateContributeFeedbackParams(params) {
+    const result = ContributeFeedbackParamsSchema.safeParse(params);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`);
+    return { success: false, error: errors.join("; ") };
+}
+//# sourceMappingURL=contribute-feedback.js.map

package/dist/schemas/registry.js

@@ -21,6 +21,7 @@ import { SearchTranscriptsParamsSchema } from "./search-transcripts.js";
 import { PrepareContextParamsSchema } from "./prepare-context.js";
 import { AbsorbObservationsParamsSchema } from "./absorb-observations.js";
 import { ListThreadsParamsSchema, ResolveThreadParamsSchema } from "./thread.js";
+import { ContributeFeedbackParamsSchema } from "./contribute-feedback.js";
 /**
  * Map of canonical tool names → Zod schemas.
  * Aliases (gitmem-r, gm-open, etc.) are resolved to canonical names before lookup.
@@ -43,6 +44,7 @@ const TOOL_SCHEMAS = {
     absorb_observations: AbsorbObservationsParamsSchema,
     list_threads: ListThreadsParamsSchema,
     resolve_thread: ResolveThreadParamsSchema,
+    contribute_feedback: ContributeFeedbackParamsSchema,
 };
 /**
  * Map of alias → canonical name for all tool aliases.
@@ -114,6 +116,9 @@ const ALIAS_MAP = {
     // archive_learning — no schema yet
     "gitmem-al": "archive_learning",
     "gm-archive": "archive_learning",
+    // contribute_feedback
+    "gitmem-fb": "contribute_feedback",
+    "gm-feedback": "contribute_feedback",
     // graph_traverse — no schema yet
     "gitmem-graph": "graph_traverse",
     "gm-graph": "graph_traverse",

package/dist/server.js

@@ -35,6 +35,7 @@ import { promoteSuggestion } from "./tools/promote-suggestion.js";
 import { dismissSuggestion } from "./tools/dismiss-suggestion.js";
 import { cleanupThreads } from "./tools/cleanup-threads.js";
 import { archiveLearning } from "./tools/archive-learning.js";
+import { contributeFeedback } from "./tools/contribute-feedback.js";
 import { getCacheStatus, checkCacheHealth, flushCache, startBackgroundInit, } from "./services/startup.js";
 import { getEffectTracker } from "./services/effect-tracker.js";
 import { RIPPLE, ANSI } from "./services/display-protocol.js";
@@ -214,6 +215,11 @@ export function createServer() {
                 case "gm-archive":
                     result = await archiveLearning(toolArgs);
                     break;
+                case "contribute_feedback":
+                case "gitmem-fb":
+                case "gm-feedback":
+                    result = await contributeFeedback(toolArgs);
+                    break;
                 case "gitmem-help": {
                     const tier = getTier();
                     const commands = [
@@ -239,6 +245,7 @@ export function createServer() {
                         { alias: "gitmem-health", full: "health", description: "Show write health for fire-and-forget operations" },
                         { alias: "gitmem-al", full: "archive_learning", description: "Archive a scar/win/pattern (is_active=false)" },
                         { alias: "gitmem-graph", full: "graph_traverse", description: "Traverse knowledge graph over institutional memory" },
+                        { alias: "gitmem-fb", full: "contribute_feedback", description: "Submit feedback about gitmem (10/session limit)" },
                     ];
                     if (hasBatchOperations()) {
                         commands.push({ alias: "gitmem-rsb", full: "record_scar_usage_batch", description: "Track multiple scars (batch)" });

package/dist/services/feedback-remote.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Remote feedback submission via Supabase anon key.
+ *
+ * This uses the PUBLIC anon key (designed to be shipped in client apps).
+ * RLS restricts anon to INSERT-only on community_feedback.
+ * Separate from supabase-client.ts because it uses the anon key, not service role.
+ */
+export interface FeedbackPayload {
+    feedback_id: string;
+    type: string;
+    tool: string;
+    description: string;
+    severity: string;
+    suggested_fix?: string;
+    context?: string;
+    gitmem_version: string;
+    agent_identity?: string;
+    install_id?: string | null;
+    client_timestamp: string;
+}
+export declare function submitFeedbackRemote(payload: FeedbackPayload): Promise<void>;
+//# sourceMappingURL=feedback-remote.d.ts.map

package/dist/services/feedback-remote.js

@@ -0,0 +1,27 @@
+/**
+ * Remote feedback submission via Supabase anon key.
+ *
+ * This uses the PUBLIC anon key (designed to be shipped in client apps).
+ * RLS restricts anon to INSERT-only on community_feedback.
+ * Separate from supabase-client.ts because it uses the anon key, not service role.
+ */
+const FEEDBACK_URL = "https://cjptxyezuxdiinufgrrm.supabase.co/rest/v1/community_feedback";
+const FEEDBACK_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNqcHR4eWV6dXhkaWludWZncnJtIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjYxODY3MDMsImV4cCI6MjA4MTc2MjcwM30.L0oZy3LYCMikmZ15IUU5DnfJmucM37DJ14nUkM3AreY";
+export async function submitFeedbackRemote(payload) {
+    const response = await fetch(FEEDBACK_URL, {
+        method: "POST",
+        headers: {
+            "apikey": FEEDBACK_ANON_KEY,
+            "Authorization": `Bearer ${FEEDBACK_ANON_KEY}`,
+            "Content-Type": "application/json",
+            "Content-Profile": "public",
+            "Prefer": "return=minimal",
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Feedback submit failed: ${response.status} - ${text.slice(0, 200)}`);
+    }
+}
+//# sourceMappingURL=feedback-remote.js.map

package/dist/services/feedback-sanitizer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Feedback Sanitizer
+ *
+ * Strips PII and sensitive data from feedback text before local storage
+ * or remote submission. Reuses patterns from diagnostics/anonymizer.ts.
+ */
+/**
+ * Sanitize feedback text by removing PII, secrets, code blocks, and env vars.
+ */
+export declare function sanitizeFeedbackText(text: string): string;
+//# sourceMappingURL=feedback-sanitizer.d.ts.map

package/dist/services/feedback-sanitizer.js

@@ -0,0 +1,28 @@
+/**
+ * Feedback Sanitizer
+ *
+ * Strips PII and sensitive data from feedback text before local storage
+ * or remote submission. Reuses patterns from diagnostics/anonymizer.ts.
+ */
+/** Regex patterns for sensitive data (subset of anonymizer patterns) */
+const PATTERNS = {
+    HOME_PATH: /(?:\/Users\/[^\/\s]+|\/home\/[^\/\s]+|C:\\Users\\[^\\]+)/gi,
+    EMAIL: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+    API_KEY: /(?:sk|pk)[_-](?:test|live|or)?[_-]?[a-zA-Z0-9]{10,}/gi,
+    JWT: /eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]*/g,
+    BEARER_TOKEN: /Bearer\s+[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]*/gi,
+};
+/**
+ * Sanitize feedback text by removing PII, secrets, code blocks, and env vars.
+ */
+export function sanitizeFeedbackText(text) {
+    return text
+        .replace(PATTERNS.HOME_PATH, "[PATH]")
+        .replace(PATTERNS.EMAIL, "[EMAIL]")
+        .replace(PATTERNS.API_KEY, "[KEY]")
+        .replace(PATTERNS.BEARER_TOKEN, "[TOKEN]")
+        .replace(PATTERNS.JWT, "[TOKEN]")
+        .replace(/```[\s\S]*?```/g, "[CODE_BLOCK]")
+        .replace(/\$[A-Z_]+=[^\s]+/g, "[ENV_VAR]");
+}
+//# sourceMappingURL=feedback-sanitizer.js.map

package/dist/services/gitmem-dir.d.ts

@@ -51,6 +51,14 @@ export declare function getSessionPath(sessionId: string, filename: string): str
  * Precedence (handled by callers): explicit param > config.json > "default"
  */
 export declare function getConfigProject(): string | null;
+/**
+ * Check if feedback submission is enabled in .gitmem/config.json
+ */
+export declare function isFeedbackEnabled(): boolean;
+/**
+ * Get the install_id from .gitmem/config.json (anonymous install identifier)
+ */
+export declare function getInstallId(): string | null;
 /**
  * Clear the cached path (for testing)
  */

package/dist/services/gitmem-dir.js

@@ -130,6 +130,35 @@ export function getConfigProject() {
     }
     return null;
 }
+/**
+ * Check if feedback submission is enabled in .gitmem/config.json
+ */
+export function isFeedbackEnabled() {
+    try {
+        const configPath = path.join(getGitmemDir(), "config.json");
+        if (fs.existsSync(configPath)) {
+            const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            return raw.feedback_enabled === true;
+        }
+    }
+    catch { }
+    return false;
+}
+/**
+ * Get the install_id from .gitmem/config.json (anonymous install identifier)
+ */
+export function getInstallId() {
+    try {
+        const configPath = path.join(getGitmemDir(), "config.json");
+        if (fs.existsSync(configPath)) {
+            const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            if (raw.install_id && typeof raw.install_id === "string")
+                return raw.install_id;
+        }
+    }
+    catch { }
+    return null;
+}
 /**
  * Clear the cached path (for testing)
  */

package/dist/services/session-state.d.ts

@@ -25,12 +25,13 @@ interface SessionContext {
     observations: Observation[];
     children: SessionChild[];
     threads: ThreadObject[];
+    feedbackSubmitCount: number;
 }
 /**
  * Set the current active session
  * Called by session_start
  */
-export declare function setCurrentSession(context: Omit<SessionContext, 'recallCalled' | 'surfacedScars' | 'confirmations' | 'reflections' | 'observations' | 'children' | 'threads'> & {
+export declare function setCurrentSession(context: Omit<SessionContext, 'recallCalled' | 'surfacedScars' | 'confirmations' | 'reflections' | 'observations' | 'children' | 'threads' | 'feedbackSubmitCount'> & {
     surfacedScars?: SurfacedScar[];
     observations?: Observation[];
     children?: SessionChild[];
@@ -133,6 +134,14 @@ export declare function setThreads(threads: ThreadObject[]): void;
  * : Get threads for the current session
  */
 export declare function getThreads(): ThreadObject[];
+/**
+ * Get the current feedback submission count for rate limiting.
+ */
+export declare function getFeedbackCount(): number;
+/**
+ * Increment and return the feedback submission count.
+ */
+export declare function incrementFeedbackCount(): number;
 /**
  * : Resolve a thread in session state by ID.
  * Returns the resolved thread or null if not found.

package/dist/services/session-state.js

@@ -11,6 +11,8 @@
  *
  * This allows recall() to always assign variants even without explicit parameters.
  */
+import fs from "fs";
+import { getSessionPath } from "./gitmem-dir.js";
 // Global session state (single active session per MCP server instance)
 let currentSession = null;
 /**
@@ -27,6 +29,7 @@ export function setCurrentSession(context) {
         observations: context.observations || [],
         children: context.children || [],
         threads: context.threads || [],
+        feedbackSubmitCount: 0,
     };
     console.error(`[session-state] Active session set: ${context.sessionId}${context.linearIssue ? ` (issue: ${context.linearIssue})` : ''}`);
 }
@@ -98,7 +101,28 @@ export function addSurfacedScars(scars) {
  * Get all surfaced scars for the current session
  */
 export function getSurfacedScars() {
-    return currentSession?.surfacedScars || [];
+    // Return in-memory if available
+    if (currentSession?.surfacedScars && currentSession.surfacedScars.length > 0) {
+        return currentSession.surfacedScars;
+    }
+    // Fallback: recover from per-session file if in-memory was lost (MCP restart)
+    if (currentSession?.sessionId) {
+        try {
+            const sessionFilePath = getSessionPath(currentSession.sessionId, "session.json");
+            if (fs.existsSync(sessionFilePath)) {
+                const data = JSON.parse(fs.readFileSync(sessionFilePath, "utf-8"));
+                if (data.surfaced_scars && Array.isArray(data.surfaced_scars) && data.surfaced_scars.length > 0) {
+                    currentSession.surfacedScars = data.surfaced_scars;
+                    console.error(`[session-state] Recovered ${data.surfaced_scars.length} surfaced scars from file`);
+                    return data.surfaced_scars;
+                }
+            }
+        }
+        catch (error) {
+            console.warn("[session-state] Failed to recover surfaced scars from file:", error);
+        }
+    }
+    return [];
 }
 /**
  * Add scar confirmations (refute-or-obey) to the current session.
@@ -247,6 +271,20 @@ export function setThreads(threads) {
 export function getThreads() {
     return currentSession?.threads || [];
 }
+/**
+ * Get the current feedback submission count for rate limiting.
+ */
+export function getFeedbackCount() {
+    return currentSession?.feedbackSubmitCount ?? 0;
+}
+/**
+ * Increment and return the feedback submission count.
+ */
+export function incrementFeedbackCount() {
+    if (!currentSession)
+        return 0;
+    return ++currentSession.feedbackSubmitCount;
+}
 /**
  * : Resolve a thread in session state by ID.
  * Returns the resolved thread or null if not found.

package/dist/tools/confirm-scars.js

@@ -108,6 +108,10 @@ function persistConfirmationsToFile(confirmations) {
             return;
         const data = JSON.parse(fs.readFileSync(sessionFilePath, "utf8"));
         data.confirmations = confirmations;
+        // Also persist surfaced_scars so they survive MCP restart for reflect_scars
+        if (session.surfacedScars && session.surfacedScars.length > 0) {
+            data.surfaced_scars = session.surfacedScars;
+        }
         fs.writeFileSync(sessionFilePath, JSON.stringify(data, null, 2));
         console.error(`[confirm_scars] Confirmations persisted to ${sessionFilePath}`);
     }

package/dist/tools/contribute-feedback.d.ts

@@ -0,0 +1,21 @@
+/**
+ * contribute_feedback Tool
+ *
+ * Submit feedback about gitmem — feature requests, bug reports,
+ * friction points, or suggestions. Always saved locally to .gitmem/feedback/.
+ * If opted in via config, sent anonymously to improve gitmem.
+ *
+ * Rate limited to 10 submissions per session.
+ */
+import type { ContributeFeedbackParams } from "../schemas/contribute-feedback.js";
+export interface ContributeFeedbackResult {
+    success: boolean;
+    id?: string;
+    path?: string;
+    remote_submitted: boolean;
+    display?: string;
+    error?: string;
+    performance_ms: number;
+}
+export declare function contributeFeedback(params: ContributeFeedbackParams): Promise<ContributeFeedbackResult>;
+//# sourceMappingURL=contribute-feedback.d.ts.map

package/dist/tools/contribute-feedback.js

@@ -0,0 +1,125 @@
+/**
+ * contribute_feedback Tool
+ *
+ * Submit feedback about gitmem — feature requests, bug reports,
+ * friction points, or suggestions. Always saved locally to .gitmem/feedback/.
+ * If opted in via config, sent anonymously to improve gitmem.
+ *
+ * Rate limited to 10 submissions per session.
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+import { v4 as uuidv4 } from "uuid";
+import * as fs from "fs";
+import * as path from "path";
+import { getCurrentSession, getFeedbackCount, incrementFeedbackCount } from "../services/session-state.js";
+import { getGitmemDir, sanitizePathComponent } from "../services/gitmem-dir.js";
+import { isFeedbackEnabled, getInstallId } from "../services/gitmem-dir.js";
+import { getAgentIdentity } from "../services/agent-detection.js";
+import { sanitizeFeedbackText } from "../services/feedback-sanitizer.js";
+import { getEffectTracker } from "../services/effect-tracker.js";
+import { submitFeedbackRemote } from "../services/feedback-remote.js";
+import { wrapDisplay } from "../services/display-protocol.js";
+import { Timer } from "../services/metrics.js";
+const MAX_FEEDBACK_PER_SESSION = 10;
+export async function contributeFeedback(params) {
+    const timer = new Timer();
+    // 1. Check active session
+    const session = getCurrentSession();
+    if (!session) {
+        const msg = "No active session. Call session_start first.";
+        return {
+            success: false,
+            remote_submitted: false,
+            display: wrapDisplay(msg),
+            error: msg,
+            performance_ms: timer.stop(),
+        };
+    }
+    // 2. Rate limit check
+    const count = getFeedbackCount();
+    if (count >= MAX_FEEDBACK_PER_SESSION) {
+        const msg = `Feedback limit reached (${MAX_FEEDBACK_PER_SESSION}/session). Try again next session.`;
+        return {
+            success: false,
+            remote_submitted: false,
+            display: wrapDisplay(msg),
+            error: msg,
+            performance_ms: timer.stop(),
+        };
+    }
+    incrementFeedbackCount();
+    // 3. Sanitize text fields
+    const sanitizedDescription = sanitizeFeedbackText(params.description);
+    const sanitizedFix = params.suggested_fix ? sanitizeFeedbackText(params.suggested_fix) : undefined;
+    const sanitizedContext = params.context ? sanitizeFeedbackText(params.context) : undefined;
+    // 4. Build feedback record
+    const id = uuidv4();
+    const shortId = id.slice(0, 8);
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10); // YYYY-MM-DD
+    const record = {
+        id,
+        type: params.type,
+        tool: params.tool,
+        description: sanitizedDescription,
+        severity: params.severity,
+        suggested_fix: sanitizedFix,
+        context: sanitizedContext,
+        timestamp: now.toISOString(),
+        gitmem_version: pkg.version,
+        agent_identity: getAgentIdentity(),
+        session_id: session.sessionId,
+    };
+    // 5. Local write: .gitmem/feedback/{YYYY-MM-DD}-{type}-{short-id}.json
+    const feedbackDir = path.join(getGitmemDir(), "feedback");
+    if (!fs.existsSync(feedbackDir)) {
+        fs.mkdirSync(feedbackDir, { recursive: true });
+    }
+    const filename = `${dateStr}-${params.type}-${shortId}.json`;
+    sanitizePathComponent(filename, "feedback filename");
+    const filePath = path.join(feedbackDir, filename);
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2));
+    // 6. Remote write (if feedback_enabled in config)
+    let remoteSubmitted = false;
+    if (isFeedbackEnabled()) {
+        const installId = getInstallId();
+        const remotePayload = {
+            ...record,
+            install_id: installId,
+        };
+        // Fire-and-forget via effect tracker
+        const tracker = getEffectTracker();
+        tracker.track("feedback", "remote-submit", async () => {
+            await submitFeedbackRemote({
+                feedback_id: id,
+                type: params.type,
+                tool: params.tool,
+                description: sanitizedDescription,
+                severity: params.severity,
+                suggested_fix: sanitizedFix,
+                context: sanitizedContext,
+                gitmem_version: pkg.version,
+                agent_identity: getAgentIdentity(),
+                install_id: installId,
+                client_timestamp: now.toISOString(),
+            });
+            return remotePayload;
+        });
+        remoteSubmitted = true;
+    }
+    const latencyMs = timer.stop();
+    const remaining = MAX_FEEDBACK_PER_SESSION - getFeedbackCount();
+    const remoteNote = remoteSubmitted ? " (queued for remote)" : "";
+    const display = `Feedback recorded: ${id} (${remaining} remaining this session)\nType: ${params.type} | Tool: ${params.tool} | Severity: ${params.severity}\nSaved to .gitmem/feedback/${filename}${remoteNote}\n(${latencyMs}ms)`;
+    return {
+        success: true,
+        id,
+        path: filePath,
+        remote_submitted: remoteSubmitted,
+        display: wrapDisplay(display),
+        performance_ms: latencyMs,
+    };
+}
+//# sourceMappingURL=contribute-feedback.js.map