mixdog 0.9.24 → 0.9.25

package/src/runtime/memory/lib/memory-cycle3.mjs

@@ -11,13 +11,17 @@ function __mixdogMemoryLog(...args) {
 // {{CORE_REVIEW}} block for defaults/cycle3-review-prompt.md, then asks the
 // maintenance-preset LLM for one verdict per id. By default Cycle3 performs
 // conservative cleanup: safe compression updates and strict duplicate merges
-// are applied, while deletes stay proposals unless explicitly confirmed.
+// are applied. Deletes now also apply in conservative mode when the model
+// tags the entry as clear junk (a whitelisted junk reason) and — for
+// redundant-with-default reasons — the text actually echoes a current rule,
+// bounded by a per-run delete cap so a run keeps a safety margin instead of
+// nuking the whole set. Unreasoned / non-junk deletes still require APPLY.
 //
 // Verdict line grammar (mirrors parseUnifiedFormat in memory-cycle2.mjs):
 //   <id>|keep
 //   <id>|update|<element>|<summary>
 //   <id>|merge|<target_id>|<source_ids_csv>
-//   <id>|delete
+//   <id>|delete|<reason>
 
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
@@ -136,6 +140,58 @@ function isStrictDuplicate(a, b) {
   return sim >= 0.78
 }
 
+// Whitelisted delete reasons that conservative mode may auto-apply. These are
+// the "clear junk" classes: a copy of a built-in/default rule, a bare
+// restatement, an obsolete/already-implemented decision, or a past-event log.
+// Anything outside this set (or a bare `delete` with no reason) stays held for
+// APPLY CYCLE3 so genuinely durable rules are never removed unattended.
+const SAFE_DELETE_REASONS = new Set([
+  'duplicate', 'dup', 'duplicate_of_default', 'default', 'redundant',
+  'restatement', 'restate', 'restates_default',
+  'obsolete', 'implemented', 'done', 'completed', 'resolved',
+  'superseded_decision', 'stale', 'past_event', 'event_log', 'log',
+])
+// Reasons that claim redundancy with a built-in/default rule — these demand
+// corroboration (the core text must actually echo the current rules digest)
+// before a conservative auto-delete, so a mislabelled durable rule survives.
+const DEFAULT_ECHO_REASONS = new Set([
+  'duplicate', 'dup', 'duplicate_of_default', 'default', 'redundant',
+  'restatement', 'restate', 'restates_default',
+])
+
+function normalizeDeleteReason(reason) {
+  return String(reason ?? '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+}
+
+// Max trigram similarity of `text` against any substantive line of the current
+// rules digest — how strongly a core entry echoes a built-in rule.
+function digestRedundancy(text, rulesDigest) {
+  if (!text || !rulesDigest) return 0
+  const lines = String(rulesDigest).split('\n').map(l => l.trim()).filter(l => l.length >= 12)
+  let best = 0
+  for (const line of lines) {
+    const d = charDice(text, line)
+    if (d > best) best = d
+    if (best >= 0.9) break
+  }
+  return best
+}
+
+function isSafeConservativeDelete(core, action, rulesDigest) {
+  const reason = normalizeDeleteReason(action?.reason)
+  if (!reason) return { ok: false, reason: 'delete needs a junk reason → APPLY CYCLE3' }
+  if (!SAFE_DELETE_REASONS.has(reason)) return { ok: false, reason: `delete reason "${reason}" not in safe set → APPLY CYCLE3` }
+  if (DEFAULT_ECHO_REASONS.has(reason)) {
+    const red = digestRedundancy(coreText(core), rulesDigest)
+    if (red < 0.5) return { ok: false, reason: `not redundant with defaults (sim=${red.toFixed(2)})` }
+  }
+  return { ok: true, reason }
+}
+
 function formatRelatedRow(r) {
   const tag = r.project_id ? r.project_id : 'COMMON'
   const stat = r.status ? `[${r.status}]` : '[?]'
@@ -206,7 +262,8 @@ function parseVerdicts(raw, idSet) {
       }
       actions.push({ id, verb: 'merge', targetId, sourceIds })
     } else if (verb === 'delete') {
-      actions.push({ id, verb: 'delete' })
+      const reason = (parts[2] ?? '').trim()
+      actions.push({ id, verb: 'delete', reason: reason || null })
     } else if (verb === 'superseded' || verb === 'supersede') {
       // Require newer-id proof: `id|superseded|<newer_id>`. Without a valid
       // newer active core id the supersession has no evidence → drop to keep.
@@ -553,6 +610,10 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
   const held = { updated: 0, merged: 0, deleted: 0, superseded: 0 }
   const details = []
   const touched = new Set() // ids already acted on this cycle — avoid double action
+  // Safety margin: even when every junk verdict is legitimate, a single
+  // conservative run applies at most this many outright deletes and holds the
+  // rest for the next pass. Prevents an over-eager model from clearing the set.
+  const conservativeDeleteCap = Math.max(1, Math.ceil(cores.length * 0.35))
 
   // Core-store edit/delete calls are the mutation unit; checkpoints sit before
   // each action/source and after each awaited unit, not inside one file-store write.
@@ -596,19 +657,28 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     }
     if (a.verb === 'delete') {
       proposed.deleted++
-      if (!confirmed) {
+      // confirmed → always delete. conservative → delete only clear junk (safe
+      // reason, corroborated for redundant-with-default), capped per run.
+      // proposal → always hold.
+      let applyDelete = confirmed
+      let holdReason = 'proposal mode'
+      let safeReason = null
+      if (!confirmed && conservative) {
+        const safeDel = isSafeConservativeDelete(coreById.get(a.id), a, rulesDigest)
+        if (!safeDel.ok) holdReason = safeDel.reason
+        else if (deleted >= conservativeDeleteCap) holdReason = `conservative delete cap ${conservativeDeleteCap} reached`
+        else { applyDelete = true; safeReason = safeDel.reason }
+      }
+      if (!applyDelete) {
         held.deleted++
-        details.push({
-          id: a.id, verb: 'delete', applied: false, held: true,
-          reason: conservative ? 'delete requires APPLY CYCLE3' : 'proposal mode',
-        })
+        details.push({ id: a.id, verb: 'delete', applied: false, held: true, reason: holdReason })
         touched.add(a.id)
         continue
       }
       try {
         await deleteCore(dataDir, a.id)
         deleted++
-        details.push({ id: a.id, verb: 'delete', applied: true })
+        details.push({ id: a.id, verb: 'delete', applied: true, reason: safeReason || 'confirmed' })
         touched.add(a.id)
       } catch (err) {
         if (signal?.aborted) throw signal.reason ?? err

package/src/tui/dist/index.mjs

@@ -22810,6 +22810,15 @@ function createToolCardResults({
 }
 
 // src/tui/engine/agent-job-feed.mjs
+function parseInboundImagePaths(raw) {
+  if (typeof raw !== "string" || !raw) return [];
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr.filter((p) => typeof p === "string" && p.length > 0) : [];
+  } catch {
+    return [];
+  }
+}
 function createAgentJobFeed({
   runtime,
   getState,
@@ -22896,13 +22905,38 @@ function createAgentJobFeed({
         set(agentStatusState({ force: true }));
       }
       const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
-      if (!modelContent) return true;
-      enqueue(modelContent, {
+      const imagePaths = parseInboundImagePaths(event?.meta?.image_paths);
+      if (!modelContent && imagePaths.length === 0) return true;
+      const enqueueOpts = {
         mode: "task-notification",
         priority: "next",
         key: notificationKey || void 0,
         displayText: delivery.displayText || text
-      });
+      };
+      if (imagePaths.length > 0) {
+        void (async () => {
+          if (getDisposed()) return;
+          const parts = [];
+          if (modelContent) parts.push({ type: "text", text: modelContent });
+          for (const p of imagePaths) {
+            let att = null;
+            try {
+              att = await readImageAttachmentFromPath(p);
+            } catch {
+              att = null;
+            }
+            if (!att) continue;
+            if (att.metadataText) parts.push({ type: "text", text: att.metadataText });
+            parts.push({ type: "image", data: att.content, mimeType: att.mediaType || "image/png" });
+          }
+          if (getDisposed()) return;
+          const hasImage = parts.some((part) => part.type === "image");
+          if (!hasImage && !modelContent) return;
+          enqueue(hasImage ? parts : modelContent, enqueueOpts);
+        })();
+        return true;
+      }
+      enqueue(modelContent, enqueueOpts);
       return true;
     });
   }

package/src/tui/engine/agent-job-feed.mjs

@@ -23,6 +23,20 @@ import {
   notificationQueueKey,
   resolveTuiRuntimeNotificationDelivery,
 } from './notification-plan.mjs';
+import { readImageAttachmentFromPath } from '../paste-attachments.mjs';
+
+// Channel inbound images arrive as a JSON-array-of-paths meta value (stringified
+// across the notify IPC boundary). Parse defensively; a malformed value simply
+// yields no images and the notification degrades to its text body.
+function parseInboundImagePaths(raw) {
+  if (typeof raw !== 'string' || !raw) return [];
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr.filter((p) => typeof p === 'string' && p.length > 0) : [];
+  } catch {
+    return [];
+  }
+}
 
 export function createAgentJobFeed({
   runtime,
@@ -117,13 +131,38 @@ export function createAgentJobFeed({
         set(agentStatusState({ force: true }));
       }
       const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
-      if (!modelContent) return true;
-      enqueue(modelContent, {
+      const imagePaths = parseInboundImagePaths(event?.meta?.image_paths);
+      if (!modelContent && imagePaths.length === 0) return true;
+      const enqueueOpts = {
         mode: 'task-notification',
         priority: 'next',
         key: notificationKey || undefined,
         displayText: delivery.displayText || text,
-      });
+      };
+      if (imagePaths.length > 0) {
+        // Read each downloaded image into a real image content block so the
+        // channel turn is vision-visible. Async, but the notification is
+        // already "handled" (return true) — the enqueue lands on resolve.
+        // Any unreadable path is skipped; if none load, fall back to text.
+        void (async () => {
+          if (getDisposed()) return;
+          const parts = [];
+          if (modelContent) parts.push({ type: 'text', text: modelContent });
+          for (const p of imagePaths) {
+            let att = null;
+            try { att = await readImageAttachmentFromPath(p); } catch { att = null; }
+            if (!att) continue;
+            if (att.metadataText) parts.push({ type: 'text', text: att.metadataText });
+            parts.push({ type: 'image', data: att.content, mimeType: att.mediaType || 'image/png' });
+          }
+          if (getDisposed()) return;
+          const hasImage = parts.some((part) => part.type === 'image');
+          if (!hasImage && !modelContent) return;
+          enqueue(hasImage ? parts : modelContent, enqueueOpts);
+        })();
+        return true;
+      }
+      enqueue(modelContent, enqueueOpts);
       return true;
     });
   }

package/src/workflows/default/WORKFLOW.md

@@ -7,44 +7,35 @@ agents: worker, heavy-worker, reviewer, debugger, maintainer
 
 # Default Workflow
 
-HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
-"proceed", "ㄱㄱ"), NO edits, apply_patch, state-changing shell commands, or
-agent spawns. Read-only exploration only. Agreeing with a diagnosis or
-pointing out a problem is NOT approval.
+HARD APPROVAL GATE — no execution (changes, state mutations, delegation)
+before an explicit go-ahead ("do it", "proceed", "ㄱㄱ"); read-only
+exploration only. Diagnosis agreement or problem-pointing is NOT approval.
 
-Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
-(routing applies only AFTER approval)
-- Lead directly: simple 1–2 step work, plus coordination, pre-planning, config
-  changes, and final git deployment.
-- Worker: implementation that takes several steps. Heavy Worker:
-  high-complexity, multi-step implementation.
-- Reviewer: verify implementation scopes (diff, regressions, missing checks).
-- Debugger: very high complexity, or when root-causing has already failed at
-  least once.
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity
+(after approval):
+- Lead directly: simple 1–2 step work, coordination, config, git deployment.
+- Worker: multi-step implementation. Heavy Worker: high-complexity scopes.
+- Reviewer: verify implementation scopes. Debugger: very high complexity, or
+  root-causing already failed once.
 
-1. Plan — discuss the request with the user, form a plan, wait for approval.
-   Only an explicit go-ahead ("do it", "proceed") is approval; agreeing with
-   a diagnosis or pointing out a problem is NOT execution approval.
-2. Delegate — split into the maximum number of independent scopes.
-   - PARALLEL across independent scopes by default (implementation, analysis,
-     review, debugging alike); spawn every scope in the SAME turn. Shared or
-     cross-cutting code does NOT justify merging — split per path and verify
-     the shared parts yourself. The only single scope is a genuinely
-     inseparable dependency; then state it.
-   - SEQUENTIAL within a single complex scope: ordered steps with a
-     build/test-green gate between them, not one shot.
-   - Write briefs per the Lead brief contract.
-   - After spawning async agents, END THE TURN — no polling, guessing, or
-     dependent work until the completion notification resumes you.
-3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
-   same turn, never deferred or batched; wait for its result. Fact-check agent
-   responses and cross-check implementation and review results yourself before
-   acting. Send fixes back to the original scope and loop verify -> fix ->
-   re-verify until clean. Skip review only for simple, low-risk tasks. If the
-   user asks for debugging, or a bug survives 2+ fix cycles, have the debugger
-   investigate first instead of another fix round.
-4. Report — synthesize outcome + key evidence (never forward raw agent
-   output), state the final state, and ask about ship/deploy when relevant.
-   Prepare deploy/build/commit only after user feedback with no issues.
+1. Plan — present a draft plan before ANY implementation; if not approved,
+   revise and re-present (ping-pong) until an explicit go-ahead.
+2. Delegate — split into the maximum independent scopes; spawn all in the
+   SAME turn (parallel by default; sequential steps only inside one complex
+   scope, gated build/test-green). Shared/cross-cutting code does NOT justify
+   merging scopes — split per path, verify shared parts yourself; a genuinely
+   inseparable single scope must be stated. Briefs per the Lead brief
+   contract. After spawning async agents, END THE TURN.
+3. Review — pair one reviewer 1:1 per implementation scope, same turn.
+   Cross-check agent results yourself; send fixes back to the original scope
+   and loop fix -> re-verify until clean. Skip only for simple low-risk work.
+   Debugger first when the user asks for debugging or a bug survives 2+ fix
+   cycles.
+   On each agent report: tell the user what was received (scope + verdict)
+   and how work proceeds, marked in-progress — never as a conclusion.
+4. Report — final report briefs the whole work vs the approved plan and the
+   verified result, distinct from interim updates. Never forward raw agent
+   output. Ask about ship/deploy when relevant; deploy/build/commit only
+   after user feedback with no issues.
 
-On any major change or direction shift mid-work, pause and re-consult the user.
+On major direction shifts mid-work, pause and re-consult the user.

package/src/workflows/solo/WORKFLOW.md

@@ -7,27 +7,22 @@ agents:
 
 # Solo Workflow
 
-HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
-"proceed", "ㄱㄱ"), NO edits, apply_patch, or state-changing shell commands.
-Read-only exploration only. Agreeing with a diagnosis or pointing out a
-problem is NOT approval.
+HARD APPROVAL GATE — no execution (changes, state mutations) before an
+explicit go-ahead ("do it", "proceed", "ㄱㄱ"); read-only exploration only.
+Diagnosis agreement or problem-pointing is NOT approval.
 
-1. Plan — Lead discusses the request with the user, forms a plan, and waits for
-   approval before execution.
-   Only an explicit go-ahead is approval; diagnosis agreement is not. When
-   ambiguous, restate the plan and ask before executing.
-2. Execute — Lead performs all implementation, research, debugging, review, and
-   verification work directly. Delegation to any agent is forbidden.
-3. Verify — Lead checks the result directly, fixes issues directly, and repeats
-   until the work is clean or a blocker must be reported.
-4. Report — Lead summarizes the final state, verification result, and any
-   remaining risk or requested next step. Only after user feedback with no
-   issues prepare deploy/build/commit.
+1. Plan — present a draft plan before ANY implementation; if not approved,
+   revise and re-present (ping-pong) until an explicit go-ahead. When
+   ambiguous, restate the plan and ask.
+2. Execute — Lead does all work directly; delegation forbidden. Interim
+   updates are marked in-progress — never phrased as conclusions.
+3. Verify — check and fix directly until clean or a blocker is reported.
+4. Report — final report briefs the whole work vs the approved plan, the
+   verification result, and remaining risk/next step, distinct from interim
+   updates. Deploy/build/commit only after user feedback with no issues.
 
-On any major change or direction shift mid-work, pause and re-consult the user
-before continuing.
+On major direction shifts mid-work, pause and re-consult the user.
 
 Delegation rule:
-- Do not delegate, spawn, send, or ask any agent to perform work.
-- Ignore any available-agent section while this workflow is active; all work is
-  handled by Lead directly.
+- Never delegate, spawn, send, or ask any agent to perform work; ignore any
+  available-agent section while this workflow is active.