memorix 1.8.5 → 1.8.6

package/src/cli/commands/hooks-preview.ts

@@ -153,6 +153,7 @@ function estimateFileSize(agent: string, configPath: string): string {
     opencode: '~3KB',
     trae: '~1KB',
     dsh: '~1KB',
+    workbuddy: '~1KB',
   };
   return sizes[agent] || '~2KB';
 }
@@ -174,6 +175,8 @@ function getRulesPath(agent: string, cwd: string, global: boolean): string {
         return path.join(home, '.trae', 'rules', 'project_rules.md');
       case 'dsh':
         return path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'AGENTS.md');
+      case 'workbuddy':
+        return '';
       default:
         return '';
     }
@@ -191,6 +194,8 @@ function getRulesPath(agent: string, cwd: string, global: boolean): string {
         return path.join(cwd, '.trae', 'rules', 'project_rules.md');
       case 'dsh':
         return path.join(cwd, 'AGENTS.md');
+      case 'workbuddy':
+        return path.join(cwd, 'AGENTS.md');
       default:
         return '';
     }

package/src/cli/commands/integrate.ts

@@ -115,6 +115,7 @@ function getAgentLabel(agent: string): string {
     'gemini-cli': 'Gemini CLI',
     trae: 'Trae',
     dsh: 'DeepSeek Harness',
+    workbuddy: 'WorkBuddy',
   };
   return labels[agent] || agent;
 }
@@ -132,6 +133,7 @@ function getAgentHint(agent: string): string {
     'gemini-cli': 'settings + GEMINI.md',
     trae: 'rules',
     dsh: 'MCP patch + AGENTS.md + skills',
+    workbuddy: 'MCP + AGENTS.md',
   };
   return hints[agent] || 'integration files';
 }

package/src/cli/commands/setup.ts

@@ -31,6 +31,7 @@ import { KiroMCPAdapter } from '../../workspace/mcp-adapters/kiro.js';
 import { OpenCodeMCPAdapter } from '../../workspace/mcp-adapters/opencode.js';
 import { TraeMCPAdapter } from '../../workspace/mcp-adapters/trae.js';
 import { DshMCPAdapter } from '../../workspace/mcp-adapters/dsh.js';
+import { WorkbuddyMCPAdapter } from '../../workspace/mcp-adapters/workbuddy.js';
 import { CodeBuddyMCPAdapter } from '../../workspace/mcp-adapters/codebuddy.js';
 import { getSetupIntegrationRows as readSetupIntegrationRows } from '../../integrations/registry.js';
 import { OFFICIAL_MEMORIX_SKILLS } from '../../hooks/official-skills.js';
@@ -192,6 +193,7 @@ const SUPPORTED_SETUP_AGENTS: AgentName[] = [
   'kiro',
   'trae',
   'dsh',
+  'workbuddy',
   'pi',
 ];
 
@@ -405,6 +407,7 @@ export function getMcpAdapter(agent: McpConfigAgent): MCPConfigAdapter {
     opencode: new OpenCodeMCPAdapter(),
     trae: new TraeMCPAdapter(),
     dsh: new DshMCPAdapter(),
+    workbuddy: new WorkbuddyMCPAdapter(),
   };
   return adapters[agent];
 }
@@ -1611,7 +1614,14 @@ export async function installAgentSetup(agent: AgentName, plan: SetupPlan, globa
     }
   } else if (plan.actions.includes('hooks')) {
     const result = await installHooks(agent, targetRoot, global);
-    p.log.success(`${agent}: integration files -> ${result.configPath}`);
+    const note = (result.generated as Record<string, unknown>)?.note;
+    if (result.configPath) {
+      p.log.success(`${agent}: integration files -> ${result.configPath}`);
+    } else if (note) {
+      p.log.info(`${agent}: ${note}`);
+    } else {
+      p.log.info(`${agent}: no hooks or guidance are available at this scope`);
+    }
   } else if (plan.actions.includes('project-guidance')) {
     const rulesPath = await installAgentGuidance(agent, targetRoot, global);
     p.log.success(`${agent}: guidance -> ${rulesPath}`);

package/src/cli/commands/uninstall.ts

@@ -24,7 +24,7 @@ import * as os from 'node:os';
 
 // ── MCP config paths (documented, not modified) ────────────────────
 
-interface MCPConfigEntry {
+export interface MCPConfigEntry {
   agent: string;
   path: string;
   kind: 'project' | 'global';
@@ -66,7 +66,7 @@ function checkDshPatch(p: string): boolean {
 }
 
 /** Detects memorix MCP config entries in both global and project-level paths. */
-function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
+export function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
   const entries: MCPConfigEntry[] = [];
 
   // ── Global paths ──
@@ -236,6 +236,28 @@ function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
     note: 'Remove the memory-memorix insert row from this patch file.',
   });
 
+  // WorkBuddy — global
+  const workbuddyCfg = path.join(home, '.workbuddy', 'mcp.json');
+  entries.push({
+    agent: 'WorkBuddy',
+    path: workbuddyCfg,
+    kind: 'global',
+    format: 'json',
+    detected: checkJSON(workbuddyCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.',
+  });
+
+  // WorkBuddy — project level (project-only installs must be discoverable too)
+  const workbuddyProjectCfg = path.join(cwd, '.workbuddy', 'mcp.json');
+  entries.push({
+    agent: 'WorkBuddy',
+    path: workbuddyProjectCfg,
+    kind: 'project',
+    format: 'json',
+    detected: checkJSON(workbuddyProjectCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.',
+  });
+
   return entries;
 }
 

package/src/codegraph/task-lens.ts

@@ -143,19 +143,73 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
 // Continuation is a delivery intent, not a task lens. A request can both resume
 // prior work and be a bugfix, feature, or release task, so callers keep the
 // normal lens and add a bounded prior-work projection separately.
-const CONTINUATION_KEYWORDS = [
+//
+// Matching triggers buildHookProjectContext() and a full prior-work brief,
+// which measurably costs 2-3x an ordinary prompt (~3s → ~7.5s locally, 15s+
+// under load) — enough to blow the 10s UserPromptSubmit hook timeout, after
+// which Claude Code discards the injection entirely.
+//
+// The split below is about *evidence of intent*, not about the words alone:
+//
+//   EXPLICIT   — handoff vocabulary is deliberate on its own. "交接" and
+//                "handoff" are not said casually, so a bare mention counts.
+//   AMBIGUOUS  — "继续" / "continue" / "恢复" are everyday verbs. Bare, they
+//                are filler meaning "go on" (and "恢复" usually means "restore
+//                the service" in ops work). Carrying a real task they are a
+//                genuine resume request — `memorix resume "继续处理发布阻塞问题"`
+//                is documented usage — so they require substantive content.
+const EXPLICIT_HANDOFF_KEYWORDS = [
+  'handoff',
+  'hand off',
+  'hand over',
+  'previous session',
+  'last session',
+  'pick up where',
+  '交接',          // 覆盖「任务交接」「工作交接」
+  '接手',
+  '上次会话',
+  '上次的会话',
+];
+
+const AMBIGUOUS_CONTINUATION_KEYWORDS = [
   'continue',
   'resume',
-  'pick up',
   'carry on',
-  'previous session',
+  'pick up',
   '继续',
-  '接手',
   '恢复',
   '延续',
-  '上次会话',
 ];
 
+/**
+ * Characters that carry no task meaning on their own: punctuation, whitespace,
+ * Chinese modal particles, and the generic scaffolding words users wrap around
+ * a bare "继续" ("任务继续", "继续一下").
+ */
+const TASK_FILLER_WORDS = /\b(?:please|task|work|the|a|an)\b/giu;
+const TASK_FILLER_PHRASES = /(?:吧|了|呢|啊|吗|嘛|呀|哦|噢|一下|一起|接着|请|帮我)/gu;
+
+/** Minimum residual code points that count as a real task description. */
+const MIN_TASK_SUBSTANCE = 2;
+
+function hasSubstantiveTask(text: string, keyword: string): boolean {
+  const withoutKeyword = text.replace(
+    new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'),
+    ' ',
+  );
+  const residual = withoutKeyword
+    // English fillers are removed as whole words, so `a` in `API` and `work`
+    // in `workflow` remain meaningful task text.
+    .replace(TASK_FILLER_WORDS, ' ')
+    .replace(TASK_FILLER_PHRASES, ' ')
+    .replace(/[\s\p{P}]/gu, '');
+
+  // These are scaffolding-only phrases, not tasks. Keep `工作流` intact by
+  // checking the complete residual instead of removing `工作` as a prefix.
+  if (/^(?:任务|工作|一下|一起|接着)$/u.test(residual)) return false;
+  return Array.from(residual).length >= MIN_TASK_SUBSTANCE;
+}
+
 const LENS_PRIORITY: Exclude<TaskLensId, 'general'>[] = [
   'bugfix',
   'release',
@@ -250,11 +304,22 @@ export function resolveTaskLens(task?: string): TaskLens {
  * Detect when the caller is asking to continue existing work. This stays
  * separate from task-lens routing so "continue fixing the timeout" remains a
  * bugfix, while still receiving a compact prior-work brief.
+ *
+ * Explicit handoff vocabulary counts on its own. Everyday continuation verbs
+ * additionally require a substantive task, so a bare "继续" / "continue" — the
+ * single most common thing a user types to mean "go on" — stays on the cheap
+ * path instead of paying for a full brief on every turn.
  */
 export function isContinuationTask(task?: string): boolean {
   const normalized = (task ?? '').trim().toLowerCase();
-  return normalized.length > 0 && CONTINUATION_KEYWORDS.some((keyword) =>
-    containsTaskKeyword(normalized, keyword),
+  if (normalized.length === 0) return false;
+
+  if (EXPLICIT_HANDOFF_KEYWORDS.some((keyword) => containsTaskKeyword(normalized, keyword))) {
+    return true;
+  }
+
+  return AMBIGUOUS_CONTINUATION_KEYWORDS.some((keyword) =>
+    containsTaskKeyword(normalized, keyword) && hasSubstantiveTask(normalized, keyword),
   );
 }
 

package/src/hooks/installers/index.ts

@@ -652,6 +652,12 @@ export function getProjectConfigPath(agent: AgentName, projectRoot: string): str
       return path.join(projectRoot, '.agents', 'hooks.json');
     case 'gemini-cli':
       return path.join(projectRoot, '.gemini', 'settings.json');
+    case 'workbuddy':
+      // WorkBuddy has no hook system at all — only MCP config and project
+      // AGENTS.md guidance. Return an empty path so install, detection and
+      // uninstall all treat hooks as a no-op instead of falling through to the
+      // `.memorix/hooks.json` default (which would report a path that never exists).
+      return '';
     default:
       return path.join(projectRoot, '.memorix', 'hooks.json');
   }
@@ -697,6 +703,9 @@ export function getGlobalConfigPath(agent: AgentName): string {
     case 'dsh':
       // DSH reads the user-global AGENTS.md from its harness home.
       return path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'AGENTS.md');
+    case 'workbuddy':
+      // WorkBuddy has no user-global instructions file — guidance is project-only.
+      return '';
     default:
       return path.join(home, '.memorix', 'hooks.json');
   }
@@ -725,6 +734,9 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
       case 'dsh':
         // The user-global AGENTS.md lives in the harness home DSH reads.
         return path.join(process.env.DSH_HOME?.trim() || path.join(root, '.dsh'), 'AGENTS.md');
+      case 'workbuddy':
+        // WorkBuddy has no user-global instructions file — guidance is project-only.
+        return '';
       default:
         return path.join(root, '.agent', 'rules', 'memorix.md');
     }
@@ -752,6 +764,8 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
       return path.join(root, '.trae', 'rules', 'project_rules.md');
     case 'dsh':
       return path.join(root, 'AGENTS.md');
+    case 'workbuddy':
+      return path.join(root, 'AGENTS.md');
     default:
       return path.join(root, '.agent', 'rules', 'memorix.md');
   }
@@ -867,6 +881,12 @@ export async function detectInstalledAgents(): Promise<AgentName[]> {
     agents.push('dsh');
   } catch { /* not installed */ }
 
+  // Check for WorkBuddy (its user-level home dir ~/.workbuddy)
+  try {
+    await fs.access(path.join(home, '.workbuddy'));
+    agents.push('workbuddy');
+  } catch { /* not installed */ }
+
   return agents;
 }
 
@@ -889,6 +909,19 @@ export async function installHooks(
     };
   }
 
+  // WorkBuddy has no hook system and no user-global guidance file. Report an
+  // explicit no-op instead of a project path that is never written.
+  if (agent === 'workbuddy' && global) {
+    return {
+      agent,
+      configPath: '',
+      events: [],
+      generated: {
+        note: 'WorkBuddy has no hook system and no user-global guidance file — MCP only; no global guidance/hooks. Run `memorix setup --agent workbuddy` (without --global) to install project MCP config and AGENTS.md guidance.',
+      },
+    };
+  }
+
   // Guard: reject global install for agents that don't support it
   if (global && getGlobalConfigPath(agent) === '') {
     return {
@@ -988,6 +1021,20 @@ export async function installHooks(
           },
         };
       }
+    case 'workbuddy':
+      // WorkBuddy has no hook system — install AGENTS.md guidance only;
+      // the MCP row is installed by `memorix setup --agent workbuddy`.
+      {
+        const rulesPath = await installAgentRules(agent, projectRoot, global);
+        return {
+          agent,
+          configPath: rulesPath,
+          events: [],
+          generated: {
+            note: 'WorkBuddy has no hook system — installed AGENTS.md guidance only; the MCP row is installed by `memorix setup --agent workbuddy`.',
+          },
+        };
+      }
     case 'opencode': {
       // OpenCode uses JS plugin files for hooks
       const pluginContent = generateOpenCodePlugin();
@@ -1161,6 +1208,8 @@ export async function installHooks(
  * Rules instruct the agent to proactively use memorix for context continuity.
  */
 async function installAgentRules(agent: AgentName, projectRoot: string, global = false): Promise<string> {
+  // WorkBuddy has no user-global instructions file — guidance is project-only.
+  if (agent === 'workbuddy' && global) return '';
   const rulesContent = getAgentRulesContent(agent, global ? 'global' : 'project');
   const rulesRoot = global ? os.homedir() : projectRoot;
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global);
@@ -1355,6 +1404,12 @@ export async function uninstallHooks(
     return false;
   }
 
+  // WorkBuddy has no hook file at either scope — removing hooks is a no-op.
+  // It must not touch the generic `.memorix/hooks.json` default path.
+  if (agent === 'workbuddy') {
+    return false;
+  }
+
   // Guard: reject global uninstall for agents that don't support it
   if (global && getGlobalConfigPath(agent) === '') {
     return false;

package/src/hooks/types.ts

@@ -42,6 +42,7 @@ export type AgentName =
   | 'opencode'
   | 'trae'
   | 'dsh'
+  | 'workbuddy'
   | 'pi'
   | 'omp';
 
@@ -63,6 +64,7 @@ export const AGENT_SUPPORT_TIER: Record<AgentName, SupportTier> = {
   opencode: 'community',
   trae: 'community',
   dsh: 'community',
+  workbuddy: 'community',
   pi: 'community',
   omp: 'community',
   antigravity: 'community',

package/src/integrations/registry.ts

@@ -159,6 +159,15 @@ export const MEMORIX_INTEGRATIONS: MemorixIntegration[] = [
     surfaces: ['MCP', 'AGENTS.md', 'skills'],
     note: 'DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills.',
   },
+  {
+    agent: 'workbuddy',
+    name: 'WorkBuddy',
+    entry: 'official-config',
+    status: 'ready',
+    install: 'memorix setup --agent workbuddy',
+    surfaces: ['MCP', 'AGENTS.md'],
+    note: 'WorkBuddy support writes a memorix MCP server row into ~/.workbuddy/mcp.json (or <project>/.workbuddy/mcp.json for project installs) and guidance into AGENTS.md.',
+  },
   {
     agent: 'memcode',
     name: 'memcode',

package/src/types.ts

@@ -670,7 +670,7 @@ export interface MemoryRef {
 /** MCP config format adapter interface */
 export interface MCPConfigAdapter {
   /** Setup-only adapters may support a host that does not participate in workspace sync. */
-  readonly source: AgentTarget | 'codebuddy' | 'dsh';
+  readonly source: AgentTarget | 'codebuddy' | 'dsh' | 'workbuddy';
   /** Parse MCP server entries from a config file */
   parse(content: string): MCPServerEntry[];
   /** Generate config file content from MCP server entries */

package/src/workspace/mcp-adapters/workbuddy.ts

@@ -0,0 +1,71 @@
+import type { MCPConfigAdapter, MCPServerEntry } from '../../types.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * WorkBuddy MCP config adapter.
+ *
+ * WorkBuddy stores its MCP server list in a JSON file following the standard
+ * MCP client convention:
+ *
+ *   { "mcpServers": { [name]: { command, args, env?, url?, headers? } } }
+ *
+ * Per the official WorkBuddy MCP guide, two scopes are supported:
+ *   - user-level:    ~/.workbuddy/mcp.json
+ *   - project-level: <project>/.workbuddy/mcp.json
+ *
+ * getConfigPath returns the project-level path when a projectRoot is supplied,
+ * otherwise the user-level path — matching the existing adapter convention.
+ */
+export class WorkbuddyMCPAdapter implements MCPConfigAdapter {
+  readonly source = 'workbuddy' as const;
+
+  parse(content: string): MCPServerEntry[] {
+    try {
+      const config = JSON.parse(content);
+      const servers = config.mcpServers ?? {};
+      return Object.entries(servers).map(([name, entry]: [string, any]) => ({
+        name,
+        command: entry.command ?? '',
+        args: entry.args ?? [],
+        ...(entry.env && Object.keys(entry.env).length > 0 ? { env: entry.env } : {}),
+        ...(entry.url ? { url: entry.url } : {}),
+        ...(entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}),
+        ...(entry.disabled === true ? { disabled: true } : {}),
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  generate(servers: MCPServerEntry[]): string {
+    const mcpServers: Record<string, any> = {};
+    for (const s of servers) {
+      const entry: Record<string, any> = {};
+      if (s.url) {
+        entry.url = s.url;
+        if (s.headers && Object.keys(s.headers).length > 0) {
+          entry.headers = s.headers;
+        }
+      } else {
+        entry.command = s.command;
+        entry.args = s.args;
+      }
+      if (s.env && Object.keys(s.env).length > 0) {
+        entry.env = s.env;
+      }
+      if (s.disabled === true) {
+        entry.disabled = true;
+      }
+      mcpServers[s.name] = entry;
+    }
+    return JSON.stringify({ mcpServers }, null, 2) + '\n';
+  }
+
+  getConfigPath(projectRoot?: string): string {
+    if (projectRoot) {
+      return join(projectRoot, '.workbuddy', 'mcp.json');
+    }
+    return join(homedir(), '.workbuddy', 'mcp.json');
+  }
+}