@ddtcorex/dsh-maestro-memory 1.0.1 → 1.1.1

package/src/host/index.ts

@@ -8,24 +8,33 @@ import { buildFeedbackLine } from './memory/feedback.ts'
 import { TodoStore, resolveQuadrant, DEFAULT_VIEW_LIMIT } from './todo/store.ts'
 import { TODO_TARGETS, TODO_STATUSES } from './storage/legacy-format.ts'
 import { SuggestionQueue, enqueueSuggestion, approveSuggestions, rejectSuggestions } from './review/queue.ts'
-import { resolveMemoryRoot, suggestionsPath, globalArchivePath, userArchivePath, projectKeyArchivePath, todoArchivePath } from './storage/layout.ts'
+import { resolveMemoryRoot, suggestionsPath, globalArchivePath, userArchivePath, projectKeyArchivePath, projectArchivePath, projectMemoryPath, dailyPath, todoArchivePath } from './storage/layout.ts'
 import { appendEntryAtomicSync } from './storage/atomic-store.ts'
 import * as migration from './migration/service.ts'
 import { SyncService } from './sync/service.ts'
 import { RealGitAdapter } from './sync/git.ts'
 import { listSkillsSync, resolveDefaultMaestroSkillsDir } from './skills-browser.ts'
 import { renderSnapshot } from './prompt/snapshot.ts'
+import { installAutoMemoryHooks, DEFAULT_AUTO_MEMORY, type AutoMemoryOptions } from './auto-memory.ts'
+import { computeFiveDim } from './health-score.ts'
 
 export const inject = ['tools', 'systemPrompt', 'connection'] as const
 
 export interface MaestroMemoryConfig {
   memoryDir?: string | null
   snapshotOrder?: number
+  autoMemory?: Partial<AutoMemoryOptions>
 }
 
 export const DEFAULTS: Required<MaestroMemoryConfig> = {
   memoryDir: null,
   snapshotOrder: 500,
+  autoMemory: { ...DEFAULT_AUTO_MEMORY },
+}
+
+export const READ_ACTIONS = new Set(['list', 'expand'])
+export function isMemoryConcurrencySafe(args: any): boolean {
+  return READ_ACTIONS.has(String(args?.action ?? ''))
 }
 
 // Extended unions for memory tool (M2-PR-A + M2-PR-B queue)
@@ -49,6 +58,15 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
   const queue = new SuggestionQueue(suggestionsPath(root))
   const syncService = new SyncService(config.memoryDir ?? null, new RealGitAdapter())
 
+  // Auto-memory (opt-in, default disabled) — session/event → store
+  ctx.effect(() => {
+    const am: AutoMemoryOptions = { ...DEFAULT_AUTO_MEMORY, ...(config.autoMemory ?? {}) }
+    const dispose = installAutoMemoryHooks(ctx, store, am)
+    return () => {
+      if (typeof dispose === 'function') dispose()
+    }
+  }, 'maestro-memory: auto-memory')
+
   ctx.effect(() => {
     const dispose = ctx.systemPrompt.context({
       name: 'memory:snapshot',
@@ -98,7 +116,9 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
         date: { type: 'string', description: 'Date YYYY-MM-DD for daily track (add/list/replace/remove)' },
       },
       output: CONTENT_OUTPUT,
+      isConcurrencySafe: (args: any) => isMemoryConcurrencySafe(args),
       execute: async (args: any, exec: any) => {
+        if (exec?.signal?.aborted) throw new Error('memory aborted')
         const target = args.target as MemoryTarget
         const action = args.action as MemoryAction
         const cwd: string | undefined = args.cwd ?? exec?.agent?.session?.header?.cwd
@@ -107,6 +127,9 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
             case 'add': {
               // Batch path: entries[] takes precedence over the single target/content form.
               if (Array.isArray(args.entries)) {
+                if (exec?.agent && args.entries.some((e: any) => String(e.target ?? '').trim() === 'key')) {
+                  return { content: [{ type: 'text', text: 'key is gated — use memory_suggest target=key with reason (batch contains key)' }] }
+                }
                 if (!args.target && !args.content) {
                   // Inject the session cwd as per-entry fallback, mirroring the
                   // single-add path — otherwise project/key entries without an
@@ -121,6 +144,10 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
               } else if (!target) {
                 return { content: [{ type: 'text', text: 'add failed: target is required for single add (or pass entries[])' }] }
               }
+              // G1: gate key via agent — direct memory add for key must go through memory_suggest
+              if (target === 'key' && exec?.agent) {
+                return { content: [{ type: 'text', text: 'key is gated — use memory_suggest target=key with reason (direct memory add for key is CLI-only)' }] }
+              }
               let entryText = args.content ?? ''
               if (args.sentiment !== undefined) {
                 entryText = `${entryText.trimEnd()} ${buildFeedbackLine({
@@ -192,6 +219,7 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
     const tool = defineTool({
       name: 'memory_suggest',
       description: 'Propose memory/todo for confirmation queue (gated, requires user approve). Targets: memory/user/key/todo-*',
+      isConcurrencySafe: () => false,
       parameters: {
         target: { type: 'string', required: true, enum: ['memory', 'user', 'key', 'todo-life', 'todo-work', 'todo-project', 'todo-daily'] },
         content: { type: 'string', required: true },
@@ -199,6 +227,7 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
       },
       output: CONTENT_OUTPUT,
       execute: async (args: any, exec: any) => {
+        if (exec?.signal?.aborted) throw new Error('memory_suggest aborted')
         const target = String(args.target ?? '').trim()
         const content = String(args.content ?? '').trim()
         const reason = String(args.reason ?? '').trim()
@@ -223,6 +252,7 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
   ctx.effect(() => {
     const tool = defineTool({
       name: 'dtodo',
+      isConcurrencySafe: (args: any) => String(args?.action ?? '') === 'list',
       description: 'Todos: life/work/project/daily with IDs, status/due/quadrant, smart view (overdue/today/project/Q1-Q2, limit 8), historical daily lookup',
       parameters: {
         action: { type: 'string', required: true, enum: ['add', 'list', 'done', 'update', 'remove'] },
@@ -243,6 +273,7 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
       },
       output: CONTENT_OUTPUT,
       execute: async (args: any, exec: any) => {
+        if (exec?.signal?.aborted) throw new Error('dtodo aborted')
         const action = args.action as string
         const cwd: string | undefined = args.cwd ?? exec?.agent?.session?.header?.cwd
         const dateArg = (v: any) => (typeof v === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(v) ? v : undefined)
@@ -588,4 +619,83 @@ export function apply(ctx: any, config: MaestroMemoryConfig = {}): void {
       if (typeof dispose === 'function') dispose()
     }
   }, 'maestro-memory: rpc')
+
+  // Health dashboard handler (Task6) — loopback only, returns coverage + daily counts
+  ctx.effect(() => {
+    const conn2 = (ctx as any).connection ?? (ctx.get && ctx.get('connection'))
+    if (!conn2?.rpc?.handle) return () => {}
+    const healthChannel = '/dsh-maestro-memory-health'
+    const healthHandler = async (endpoint: string, payload: any) => {
+      try {
+        const cwdRaw = (payload && typeof payload.cwd === 'string' && payload.cwd.trim()) ? payload.cwd.trim() : ''
+        // Health requires explicit cwd; if missing, return empty (client should pass sessionCwd)
+        if (!cwdRaw) {
+          return { ok: true, value: { project: { total: 0, withSummary: 0, coverage: 100 }, daily: { counts: [0,0,0,0,0,0,0] }, longest: [] } }
+        }
+        const cwd = cwdRaw
+        const projectEntries = store.list('project', cwd)
+        const total = projectEntries.length
+        const withSummary = projectEntries.filter((e: string) => /\[summary:/.test(e)).length
+        const coverage = total ? (withSummary / total) * 100 : 100
+        // daily last 7 days
+        const dailyCounts: number[] = []
+        for (let i = 6; i >= 0; i--) {
+          const d = new Date()
+          d.setDate(d.getDate() - i)
+          const ds = d.toISOString().slice(0, 10)
+          try {
+            const list = store.list('daily', undefined, { date: ds } as any)
+            dailyCounts.push(Array.isArray(list) ? list.length : 0)
+          } catch { dailyCounts.push(0) }
+        }
+        const longest = [...projectEntries].sort((a, b) => b.length - a.length).slice(0, 5).map((e) => ({ len: e.length, preview: e.slice(0, 80).replace(/\n/g, ' ') }))
+        const fiveDim = computeFiveDim({
+          projectTotal: total,
+          withSummary,
+          dailyCounts,
+          longestLen: longest[0]?.len ?? 0,
+          hasAutoRecall: true,
+          hasSanitize: true,
+          hasGatedQueue: true,
+        })
+        const health = { project: { total, withSummary, coverage }, daily: { counts: dailyCounts }, longest, fiveDim }
+        return { ok: true, value: health }
+      } catch (e: any) {
+        return { ok: false, error: e?.message ?? String(e) }
+      }
+    }
+    const h = async (ep: string, pl: unknown, _s: AbortSignal) => {
+      const res: any = await healthHandler(ep, pl)
+      if (res.ok) return { ok: true as const, value: res.value }
+      return { ok: false as const, error: { message: res.error } }
+    }
+    const dispose2 = conn2.rpc.handle(healthChannel, h, { authority: 'loopback' })
+    return () => { if (typeof dispose2 === 'function') dispose2() }
+  }, 'maestro-memory: health')
+
+  // Propose handler for Health → queue (Task4) — loopback only
+  ctx.effect(() => {
+    const conn3 = (ctx as any).connection ?? (ctx.get && ctx.get('connection'))
+    if (!conn3?.rpc?.handle) return () => {}
+    const proposeHandler = async (endpoint: string, payload: any) => {
+      try {
+        const content = String(payload?.content ?? '').trim()
+        const reason = String(payload?.reason ?? 'promote from Health longest').trim()
+        if (!content) return { ok: false, error: 'empty content' }
+        if (!reason) return { ok: false, error: 'empty reason' }
+        const res = enqueueSuggestion(queue, 'key', content, reason, undefined as any)
+        if (!res.ok) return { ok: false, error: (res as any).message ?? 'failed' }
+        return { ok: true, value: res }
+      } catch (e: any) {
+        return { ok: false, error: e?.message ?? String(e) }
+      }
+    }
+    const wrapped = async (ep: string, pl: unknown, _s: AbortSignal) => {
+      const r: any = await proposeHandler(ep, pl)
+      if (r.ok) return { ok: true as const, value: r.value }
+      return { ok: false as const, error: { message: r.error } }
+    }
+    const d3 = conn3.rpc.handle('/dsh-maestro-memory-propose', wrapped, { authority: 'loopback' })
+    return () => { if (typeof d3 === 'function') d3() }
+  }, 'maestro-memory: propose')
 }

package/src/host/memory/sanitize.ts

@@ -0,0 +1,43 @@
+/**
+ * memory/sanitize.ts — desensitize sensitive fragments before persistence.
+ * Ported from FuRongJun-1999/dsh-memory src/hooks.ts desensitize().
+ * English labels, same 7 patterns, same residue→null semantics.
+ */
+
+export const SENSITIVE_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  { re: /sk-[A-Za-z0-9_-]{8,}/g, label: 'API key' },
+  { re: /\b(?:api[_-]?key|apikey|access[_-]?token)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: 'API key' },
+  { re: /\b(?:password|passwd|pwd)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: 'password' },
+  { re: /Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, label: 'token' },
+  // Chinese password: value must be credential-like (non-CJK run) to avoid false positives on "password is important"
+  { re: /密码\s*[:：是]\s*[A-Za-z0-9_@#$%^&*!.-]{4,}/g, label: 'password' },
+  { re: /\b\d{17}[\dXx]\b/g, label: 'ID number' },
+  { re: /\b1[3-9]\d{9}\b/g, label: 'phone number' },
+]
+
+/**
+ * Replace sensitive fragments with [Filtered:<label>].
+ * Returns null when the residue after stripping placeholders is empty
+ * (pure-credential message should be skipped, not persisted).
+ */
+export function desensitize(text: string): string | null {
+  let out = text
+  for (const { re, label } of SENSITIVE_PATTERNS) {
+    out = out.replace(re, `[Filtered:${label}]`)
+  }
+  const residue = out.replace(/\[Filtered:[^\]]+\]/g, '').trim()
+  if (!residue) return null
+  return out
+}
+
+/**
+ * Convenience wrapper for store integration: sanitize or return original
+ * when disabled. Returns { filtered, sanitized } where filtered indicates
+ * the input was pure-sensitive and should be rejected.
+ */
+export function sanitizeInput(text: string, enabled: boolean): { filtered: boolean; sanitized: string | null } {
+  if (!enabled) return { filtered: false, sanitized: text }
+  const r = desensitize(text)
+  if (r === null) return { filtered: true, sanitized: null }
+  return { filtered: false, sanitized: r }
+}

package/src/host/memory/store.ts

@@ -32,6 +32,7 @@ import {
   globalArchivePath,
   userArchivePath,
   projectKeyArchivePath,
+  projectArchivePath,
   maestroMetaDir,
 } from '../storage/layout.ts'
 import {
@@ -41,7 +42,9 @@ import {
   autoSummary,
   extractEntryDate,
   BRANCH_TAG_RE,
+  SUMMARY_TAG_RE,
 } from '../storage/legacy-format.ts'
+import { desensitize } from './sanitize.ts'
 
 export type MemoryTarget = 'memory' | 'global' | 'user' | 'project' | 'key' | 'daily'
 export type MemoryAction = 'add' | 'list' | 'replace' | 'remove' | 'archive' | 'expand'
@@ -144,7 +147,11 @@ export class MaestroMemoryStore {
       if (!cwd) throw new Error('key archive requires cwd')
       return projectKeyArchivePath(r, cwd)
     }
-    throw new Error(`archive only for memory/user/key (got ${target})`)
+    if (t === 'project') {
+      if (!cwd) throw new Error('project archive requires cwd')
+      return projectArchivePath(r, cwd)
+    }
+    throw new Error(`archive only for memory/user/key/project (got ${target})`)
   }
 
   // -------------------------------------------------------------------------
@@ -232,6 +239,22 @@ export class MaestroMemoryStore {
     return `[id:${genId()}] ${entry}`
   }
 
+  private ensureDatePrefix(entry: string): string {
+    const t = String(entry).trim()
+    if (/^\[(?:\d{4}-\d{2}-\d{2}|id:\s*[0-9a-f]{8}|branch:)/i.test(t)) return t
+    // daily entries often have [HH:MM] — keep if present (but we still want date for non-daily)
+    if (/^\[\d{1,2}:\d{2}(?::\d{2})?\]/.test(t)) return t
+    return `[${todayStamp()} ${timeStamp()}] ${t}`
+  }
+
+  private ensureAutoSummary(entry: string, target: MemoryTarget): string {
+    if (target === 'daily') return entry
+    if (SUMMARY_TAG_RE.test(entry)) return entry
+    const s = autoSummary(entry, 80).replace(/[\n\r\t\]]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 120)
+    if (!s) return entry
+    return `${entry.trimEnd()} [summary:${s}]`
+  }
+
   // -------------------------------------------------------------------------
   // Public API: add / list / replace / remove / archive / expand / snapshot
   // -------------------------------------------------------------------------
@@ -335,12 +358,12 @@ export class MaestroMemoryStore {
     return out
   }
 
-  /** Add entry (with optional branches/summary for key) */
+  /** Add entry (with optional branches/summary for key) — hardened: auto date + auto summary + desensitize */
   add(
     target: MemoryTarget,
     entry: string,
     cwd?: string,
-    opts: { branches?: string; summary?: string; date?: string } = {},
+    opts: { branches?: string; summary?: string; date?: string; desensitize?: boolean } = {},
   ): { ok: true; duplicate?: boolean; id?: string } | { ok: false; error: string } {
     try {
       this.assertNotBlocked()
@@ -350,21 +373,58 @@ export class MaestroMemoryStore {
     const t = normalizeTarget(target)
     let content = String(entry ?? '').trim()
     if (!content) return { ok: false, error: 'empty content' }
-    // For key, handle branches and summary before id generation
+    // Guard against idle-loop spam: reject trivial placeholder entries that carry
+    // no new information (e.g. "Idle", "Idle — no change"). The snapshot
+    // discipline now says to skip when idle, but keep a code-level guard as
+    // defense-in-depth so a misbehaving model cannot flood daily/project.
+    const trivialStripped = content.replace(/^\[.*?\]\s*/g, '').trim().toLowerCase()
+    if (
+      trivialStripped.startsWith('idle') ||
+      trivialStripped.startsWith('no change') ||
+      trivialStripped.startsWith('awaiting') ||
+      trivialStripped.startsWith('waiting')
+    ) {
+      // Idle/placeholder entries carry no new information; treat as duplicate/no-op
+      // rather than error so the caller can proceed without retrying. Cap at 150
+      // chars so legitimate long entries that merely mention "idle" are not blocked.
+      if (trivialStripped.length < 150) return { ok: true, duplicate: true }
+    }
+    // Desensitize by default (opt-out via {desensitize:false} for tests/internal)
+    const doDesensitize = opts.desensitize !== false
+    if (doDesensitize) {
+      const s = desensitize(content)
+      if (s === null) return { ok: false, error: 'content filtered (sensitive-only)' }
+      content = s
+    }
+    // Auto date prefix for all tracks (local calendar, preserves existing [id:/date/branch/time)
+    content = this.ensureDatePrefix(content)
+    // For key, handle branches and summary before id generation, then auto summary if still missing
     if (t === 'key') {
       if (opts.branches) content = this.applyBranchTag(content, opts.branches)
       if (opts.summary) {
         content = this.applySummaryTag(content, opts.summary)
       }
       content = this.ensureId(content)
+      content = this.ensureAutoSummary(content, t)
+    } else {
+      content = this.ensureAutoSummary(content, t)
     }
-    // For daily/project, strip hand-written date prefix? Keep simple: no stamping, store verbatim
     let file: string
     try {
       file = this.fileFor(t, cwd, opts.date)
     } catch (e: any) {
       return { ok: false, error: e?.message ?? String(e) }
     }
+    // Dedupe with stripped id+summary so summary difference doesn't create duplicate
+    try {
+      const existing = readEntriesSync(file)
+      const stripForDedupe = (s: string) => s.replace(/\[summary:[^\]]*\]\s*/g, '').replace(/^\[id:\s*[0-9a-f]{8}\]\s*/i, '').trim()
+      const probe = stripForDedupe(content)
+      const isDup = existing.some((e) => stripForDedupe(e) === probe)
+      if (isDup) return { ok: true, duplicate: true }
+    } catch {
+      // read failure → treat as no duplicate, let append handle it
+    }
     const res = appendEntryAtomicSync(file, content)
     if (!res.ok) return { ok: false, error: res.error }
     if (res.duplicate) return { ok: true, duplicate: true }
@@ -409,13 +469,14 @@ export class MaestroMemoryStore {
       let replacement = newText
       const oldEntry = matches[0]
       const oldId = /^\[id:\s*([0-9a-f]{8})\]\s*/i.exec(oldEntry)?.[1]
-      // If replacement already has summary handling? Not for replace; keep simple
       if (oldId) {
         // If replacement doesn't already have id, prepend it
         if (!/^\[id:\s*[0-9a-f]{8}\]\s*/i.test(replacement)) {
           replacement = `[id:${oldId.toLowerCase()}] ${replacement}`
         }
       }
+      replacement = this.ensureDatePrefix(replacement)
+      replacement = this.ensureAutoSummary(replacement, t)
       const idx = entries.indexOf(oldEntry)
       const next = [...entries]
       next[idx] = replacement
@@ -473,12 +534,17 @@ export class MaestroMemoryStore {
       return { ok: false, error: e?.message ?? String(e) }
     }
     const t = normalizeTarget(target)
-    if (t !== 'memory' && t !== 'user' && t !== 'key') {
-      return { ok: false, error: 'archive only for memory/user/key' }
+    if (t !== 'memory' && t !== 'user' && t !== 'key' && t !== 'project') {
+      return { ok: false, error: 'archive only for memory/user/key/project' }
     }
     const m = String(match ?? '').trim()
     if (!m) return { ok: false, error: 'empty match' }
-    const mainFile = this.fileFor(t, cwd)
+    let mainFile: string
+    try {
+      mainFile = this.fileFor(t, cwd)
+    } catch (e: any) {
+      return { ok: false, error: e?.message ?? String(e) }
+    }
     return withLockSync(dirname(mainFile), () => {
       const entries = readEntriesSync(mainFile)
       const matches = entries.filter((e) => e.includes(m))
@@ -620,7 +686,11 @@ export class MaestroArchiveStore {
       if (!cwd) throw new Error('key archive requires cwd')
       return projectKeyArchivePath(r, cwd)
     }
-    throw new Error(`archive only for memory/user/key`)
+    if (t === 'project') {
+      if (!cwd) throw new Error('project archive requires cwd')
+      return projectArchivePath(r, cwd)
+    }
+    throw new Error(`archive only for memory/user/key/project`)
   }
 
   entries(target: MemoryTarget, cwd?: string): string[] {

package/src/host/prompt/snapshot.ts

@@ -10,7 +10,7 @@ export interface SnapshotContext {
 }
 
 /** Default per-section byte budgets for the snapshot prompt. */
-export const SNAPSHOT_SECTION_CAPS = { memory: 2048, user: 4096, key: 6144 } as const
+export const SNAPSHOT_SECTION_CAPS = { memory: 2048, user: 4096, key: 6144, recentDaily: 512, autoRecall: 1024 } as const
 
 export type SnapshotSectionKey = keyof typeof SNAPSHOT_SECTION_CAPS
 
@@ -50,10 +50,11 @@ function fitSection(entries: string[], cap: number): string[] {
 }
 
 /**
- * Bounded snapshot renderer — contract từ README § System Prompt Snapshot:
+ * Bounded snapshot renderer — contract from README § System Prompt Snapshot:
  * Header (sessionId/sessionName) + USER + global MEMORY + current-project KEY
- * (branch-filtered) + end-of-turn discipline note.
- * daily và project KHÔNG inject.
+ * (branch-filtered) + Project Context (auto-recall top-4, 600 chars each)
+ * + Recent Daily + end-of-turn discipline note.
+ * Full daily/project logs are query-only; only the bounded recall slices are injected.
  */
 export function renderSnapshot(
   store: MaestroMemoryStore,
@@ -83,9 +84,42 @@ export function renderSnapshot(
   if (user.length) parts.push(`# User Memory\n${user.join('\n---\n')}`)
   if (key.length) parts.push(`# Project Key Memory\n${key.join('\n---\n')}`)
 
+  // Auto-recall: newest 4 project entries for current cwd, each truncated to 600 chars
+  // Mirrors dsh-memory timeline(limit:4, 600 chars) but file-native, no Python.
+  if (ctx.cwd) {
+    try {
+      const proj = store.list('project', ctx.cwd)
+      if (proj.length) {
+        const newest4 = proj.slice(-4).map((e) => e.slice(0, 600))
+        const fitted = fitSection(newest4, (caps as any).autoRecall ?? 1024)
+        if (fitted.length) parts.push(`# Project Context\n${fitted.join('\n---\n')}`)
+      }
+    } catch {}
+  }
+
+  // Recent daily slot (512B) — last 2 days' newest entries
+  // Keeps recent context without exceeding cap; full logs remain query-only.
+  try {
+    const recentDaily: string[] = []
+    for (let i = 0; i < 2; i++) {
+      const d = new Date()
+      d.setDate(d.getDate() - i)
+      const ds = d.toISOString().slice(0, 10)
+      try {
+        const list: string[] = store.list('daily', undefined, { date: ds } as any)
+        if (list.length) recentDaily.push(list[list.length - 1])
+      } catch {}
+    }
+    if (recentDaily.length) {
+      const fitted = fitSection(recentDaily, caps.recentDaily)
+      if (fitted.length) parts.push(`# Recent Daily\n${fitted.join('\n---\n')}`)
+    }
+  } catch {}
+
   // End-of-turn discipline note — verbatim contract (hardened: exactly once, always last)
+  // Conditional to avoid idle loops: only when turn produced meaningful progress.
   const discipline =
-    `---\nEnd of every turn you must: 1. Write daily+project via memory entries (daily+project in one call) 2. Check dtodo list (bounded, max 8)`
+    `---\nEnd of every turn — if this turn produced meaningful progress (code, decisions, learnings, or next steps): 1. Write daily+project via memory entries (daily+project in one call, skip if idle/waiting or no new information — never write entries containing only 'Idle' or placeholders) 2. Check dtodo list only if relevant (bounded, max 8)\nFor important project decisions (convention, incident, infra) use memory_suggest target=key with reason, not memory add.`
   // Defensive: strip any pre-existing discipline entry (should never occur — parts is fresh per call)
   // then append exactly once so the note is guaranteed last even for empty stores or repeated calls.
   const deduped = parts.filter((p) => p !== discipline)

package/src/host/skills-browser.ts

@@ -21,6 +21,7 @@
  */
 
 import { existsSync, readdirSync, statSync, lstatSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { join, resolve, relative } from 'node:path'
 
 export interface SkillBrowseEntry {
@@ -180,10 +181,11 @@ export async function listSkills(opts: ListSkillsOpts = {}): Promise<SkillBrowse
  * if it exists, for metadata/origin listing.
  */
 export function resolveDefaultMaestroSkillsDir(): string | null {
-  const candidates = [
-    '/home/kai/Work/htdocs/maestro-harness/maestro-skills/skills',
+  const candidates: string[] = [
+    process.env.MAESTRO_HARNESS_ROOT ? join(process.env.MAESTRO_HARNESS_ROOT, 'maestro-skills/skills') : null,
     join(process.cwd(), '../maestro-skills/skills'),
-  ]
+    join(homedir(), 'Work/htdocs/maestro-harness/maestro-skills/skills'),
+  ].filter((v): v is string => Boolean(v))
   for (const c of candidates) {
     if (existsSync(c)) return c
   }

package/src/host/storage/layout.ts

@@ -67,6 +67,14 @@ export function projectKeyPath(root: string, cwd: string): string {
 export function projectKeyArchivePath(root: string, cwd: string): string {
   return join(projectDir(root, cwd), 'KEY-archive.md')
 }
+export function projectArchivePath(root: string, cwd: string): string {
+  if (!cwd) throw new Error('projectArchivePath: cwd is required')
+  return join(projectDir(root, cwd), 'MEMORY-archive.md')
+}
+export function projectArchiveDir(root: string, cwd: string): string {
+  if (!cwd) throw new Error('projectArchiveDir: cwd is required')
+  return projectDir(root, cwd)
+}
 export function projectTodoPath(root: string, cwd: string): string {
   return join(projectDir(root, cwd), 'TODOS.md')
 }
@@ -148,12 +156,14 @@ export function allArchivePaths(root: string, cwd: string): {
   user: string
   key: string
   todo: string
+  projectMemoryArchive: string
 } {
   return {
     memory: globalArchivePath(root),
     user: userArchivePath(root),
     key: projectKeyArchivePath(root, cwd),
     todo: todoArchivePath(root),
+    projectMemoryArchive: projectArchivePath(root, cwd),
   }
 }