@goodandready/dsh-goal 0.2.11 → 0.2.13

package/lib/addon-store.js

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Lightweight JSON persistence for dsh-goal addon metadata:
+ * milestones, checklists, snapshots, and token budget metrics.
+ */
+export class AddonStore {
+  constructor(storagePath, logger = console) {
+    this.storagePath = storagePath || null;
+    this.logger = logger;
+    this.goals = new Map(); // goalId -> { milestones, snapshots, budget, issue }
+    this.saveTimer = null;
+    this.loadFromDisk();
+  }
+
+  setStoragePath(storagePath) {
+    this.storagePath = storagePath || null;
+    this.loadFromDisk();
+  }
+
+  getGoalData(goalId) {
+    if (!goalId) return null;
+    if (!this.goals.has(goalId)) {
+      this.goals.set(goalId, {
+        milestones: [],
+        snapshots: [],
+        budget: { maxTokenBudget: 0, warnedAt: null, blockedAt: null },
+        issue: null,
+      });
+    }
+    return this.goals.get(goalId);
+  }
+
+  getMilestones(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.milestones : [];
+  }
+
+  setMilestones(goalId, milestones) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    data.milestones = Array.isArray(milestones) ? milestones : [];
+    this.scheduleSave();
+  }
+
+  getSnapshots(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.snapshots : [];
+  }
+
+  addSnapshot(goalId, snapshot) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    if (!Array.isArray(data.snapshots)) data.snapshots = [];
+    data.snapshots.push(snapshot);
+    this.scheduleSave();
+  }
+
+  getBudget(goalId) {
+    const data = this.getGoalData(goalId);
+    return data ? data.budget : null;
+  }
+
+  setBudget(goalId, budget) {
+    const data = this.getGoalData(goalId);
+    if (!data) return;
+    data.budget = { ...(data.budget || {}), ...budget };
+    this.scheduleSave();
+  }
+
+  loadFromDisk() {
+    if (!this.storagePath) return;
+    try {
+      if (fs.existsSync(this.storagePath)) {
+        const raw = fs.readFileSync(this.storagePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.goals) {
+          for (const [gid, val] of Object.entries(parsed.goals)) {
+            this.goals.set(gid, {
+              milestones: Array.isArray(val.milestones) ? val.milestones : [],
+              snapshots: Array.isArray(val.snapshots) ? val.snapshots : [],
+              budget: val.budget || { maxTokenBudget: 0, warnedAt: null, blockedAt: null },
+              issue: val.issue || null,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Failed to load addon state from disk:', err?.message || err);
+    }
+  }
+
+  scheduleSave(immediate = false) {
+    if (!this.storagePath) return;
+    if (immediate) {
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
+      this.writeToDiskSync();
+      return;
+    }
+    if (!this.saveTimer) {
+      this.saveTimer = setTimeout(() => {
+        this.saveTimer = null;
+        this.writeToDiskSync();
+      }, 200);
+      if (typeof this.saveTimer.unref === 'function') {
+        this.saveTimer.unref();
+      }
+    }
+  }
+
+  writeToDiskSync() {
+    if (!this.storagePath) return;
+    try {
+      const goalsObj = {};
+      for (const [gid, val] of this.goals.entries()) {
+        goalsObj[gid] = val;
+      }
+      const payload = {
+        version: 3,
+        goals: goalsObj,
+        updatedAt: Date.now(),
+      };
+      const dir = path.dirname(this.storagePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      const tmp = `${this.storagePath}.tmp.${Date.now()}`;
+      fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+      fs.renameSync(tmp, this.storagePath);
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Failed to write addon state to disk:', err?.message || err);
+    }
+  }
+
+  /**
+   * Migrate legacy state from dsh-goal-state.json to addon format and core GoalService
+   */
+  migrateLegacyState(legacyPath, coreGoals, agent) {
+    if (!legacyPath || !fs.existsSync(legacyPath)) return false;
+    try {
+      const raw = fs.readFileSync(legacyPath, 'utf8');
+      const data = JSON.parse(raw);
+      if (!data || typeof data !== 'object' || data._migratedToAddon) return false;
+
+      let migratedAny = false;
+      const candidates = [];
+      if (data.sessions && typeof data.sessions === 'object') {
+        for (const [sid, goal] of Object.entries(data.sessions)) {
+          if (goal?.title && goal?.hasActiveGoal) {
+            candidates.push({ sessionId: sid, goal });
+          }
+        }
+      } else if (data.title && data.hasActiveGoal) {
+        candidates.push({ sessionId: 'default', goal: data });
+      }
+
+      for (const item of candidates) {
+        const legacyGoal = item.goal;
+        const goalId = legacyGoal.id || `legacy-${Date.now()}`;
+
+        // Import milestones into addon store
+        if (Array.isArray(legacyGoal.milestones) && legacyGoal.milestones.length > 0) {
+          this.setMilestones(goalId, legacyGoal.milestones.map((m, idx) => ({
+            id: m.id || `m-${idx + 1}`,
+            title: m.title || `Milestone ${idx + 1}`,
+            completed: m.status === 'completed',
+            completedAt: m.completedAt || null,
+            notes: m.notes || '',
+            dependsOn: Array.isArray(m.dependsOn) ? m.dependsOn : [],
+            checklist: Array.isArray(m.checklist) ? m.checklist : [],
+          })));
+        }
+
+        // If coreGoals is available and agent session is active, bridge to core
+        if (coreGoals && agent && typeof coreGoals.create === 'function') {
+          try {
+            const current = coreGoals.get ? coreGoals.get(agent) : null;
+            if (!current) {
+              coreGoals.create(agent, {
+                objective: legacyGoal.title,
+                maxGoalRounds: legacyGoal.maxIterations || 25,
+              });
+            }
+          } catch (e) {
+            this.logger.warn?.('[AddonStore] Migration: could not create goal in core:', e.message);
+          }
+        }
+        migratedAny = true;
+      }
+
+      data._migratedToAddon = true;
+      data._migratedAt = Date.now();
+      fs.writeFileSync(legacyPath, JSON.stringify(data, null, 2), 'utf8');
+      this.scheduleSave(true);
+      return migratedAny;
+    } catch (err) {
+      this.logger.warn?.('[AddonStore] Legacy migration failed:', err.message);
+      return false;
+    }
+  }
+
+  flushSync() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.writeToDiskSync();
+  }
+}

package/lib/client.js

@@ -1609,7 +1609,7 @@ window.__ModuleLoader__.load({
         if (!AudioCtx) return;
         const actx = new AudioCtx();
         if (actx.state === 'suspended') {
-          actx.resume().catch(() => {});
+          actx.resume().catch((err) => { console.warn('[dsh-goal] Fetch templates error:', err); });
         }
         const now = actx.currentTime;
         if (scheme === 'retro') {
@@ -2590,9 +2590,51 @@ window.__ModuleLoader__.load({
     function QuickLaunchModal({ onClose, onStart, t }) {
 
       const [title, setTitle] = useState('');
+      const [showTemplates, setShowTemplates] = useState(false);
+      const [backendTemplates, setBackendTemplates] = useState([]);
+      const [selectedTpl, setSelectedTpl] = useState(null);
+      const [tplInputs, setTplInputs] = useState({});
+      const [loadingTpls, setLoadingTpls] = useState(false);
 
       const inputRef = useRef(null);
 
+      useEffect(() => {
+        if (showTemplates && backendTemplates.length === 0) {
+          setLoadingTpls(true);
+          fetch('/dsh-goal/templates')
+            .then((r) => r.json())
+            .then((d) => {
+              if (d && Array.isArray(d.templates)) {
+                setBackendTemplates(d.templates);
+              }
+            })
+            .catch((err) => { console.warn('[dsh-goal] Fetch templates error:', err); })
+            .finally(() => setLoadingTpls(false));
+        }
+      }, [showTemplates, backendTemplates.length]);
+
+      const handleApplyTemplate = async () => {
+        if (!selectedTpl) return;
+        try {
+          const res = await fetch('/dsh-goal/action', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              action: 'instantiate_template',
+              templateId: selectedTpl.id,
+              inputs: tplInputs,
+            }),
+          });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.ok && data.template) {
+              setTitle(data.template.title);
+              setShowTemplates(false);
+            }
+          }
+        } catch (err) { console.warn('[dsh-goal] Apply template error:', err); }
+      };
+
       useEffect(() => {
 
         if (inputRef.current) inputRef.current.focus();
@@ -2782,8 +2824,94 @@ window.__ModuleLoader__.load({
                     },
                     tpl.label
                   )
+                ),
+                React.createElement(
+                  'button',
+                  {
+                    type: 'button',
+                    className: 'dsh-goal-chip-btn',
+                    style: { fontWeight: 600, borderColor: 'var(--dsw-alias-border-brand, var(--dsw-alias-border-l2))' },
+                    onClick: () => setShowTemplates(!showTemplates),
+                  },
+                  (showTemplates ? '▲ ' : '▼ ') + '📋 ' + (t('templatesTitle') || 'Engineering Templates')
                 )
               ),
+              showTemplates
+                ? React.createElement(
+                    'div',
+                    {
+                      style: {
+                        marginTop: 10,
+                        padding: '10px 12px',
+                        borderRadius: 6,
+                        border: '1px solid var(--dsw-alias-border-l1)',
+                        background: 'var(--dsw-alias-bg-hover)',
+                      },
+                    },
+                    loadingTpls
+                      ? React.createElement('div', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'Loading templates…')
+                      : React.createElement(
+                          'div',
+                          null,
+                          React.createElement(
+                            'div',
+                            { style: { display: 'flex', flexWrap: 'wrap', gap: 6, marginBottom: 8 } },
+                            backendTemplates.map((bt) =>
+                              React.createElement(
+                                'button',
+                                {
+                                  key: bt.id,
+                                  type: 'button',
+                                  className: `dsh-goal-chip-btn ${selectedTpl?.id === bt.id ? 'active' : ''}`,
+                                  style: selectedTpl?.id === bt.id ? { fontWeight: 600, border: '1px solid var(--dsw-alias-accent-primary)' } : {},
+                                  onClick: () => {
+                                    setSelectedTpl(bt);
+                                    const initial = {};
+                                    (bt.inputs || []).forEach((inp) => {
+                                      initial[inp.key] = inp.defaultValue || '';
+                                    });
+                                    setTplInputs(initial);
+                                  },
+                                },
+                                bt.title
+                              )
+                            )
+                          ),
+                          selectedTpl
+                            ? React.createElement(
+                                'div',
+                                { style: { borderTop: '1px solid var(--dsw-alias-border-l1)', paddingTop: 8 } },
+                                React.createElement('div', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginBottom: 6 } }, selectedTpl.description),
+                                (selectedTpl.inputs || []).map((inp) =>
+                                  React.createElement(
+                                    'div',
+                                    { key: inp.key, style: { marginBottom: 6 } },
+                                    React.createElement('label', { style: { fontSize: 11, display: 'block', marginBottom: 2 } }, inp.label),
+                                    React.createElement('input', {
+                                      type: 'text',
+                                      className: 'dsh-goal-card-input',
+                                      style: { width: '100%', boxSizing: 'border-box', fontSize: 12, padding: '4px 8px' },
+                                      placeholder: inp.placeholder || '',
+                                      value: tplInputs[inp.key] || '',
+                                      onChange: (e) => setTplInputs({ ...tplInputs, [inp.key]: e.target.value }),
+                                    })
+                                  )
+                                ),
+                                React.createElement(
+                                  'button',
+                                  {
+                                    type: 'button',
+                                    className: 'dsh-goal-btn dsh-goal-btn-primary',
+                                    style: { marginTop: 4, padding: '4px 10px', fontSize: 12 },
+                                    onClick: handleApplyTemplate,
+                                  },
+                                  'Apply Template'
+                                )
+                              )
+                            : null
+                        )
+                  )
+                : null
             ),
 
             React.createElement(
@@ -3398,6 +3526,17 @@ window.__ModuleLoader__.load({
 
       const isCompleted = state.state === 'COMPLETED';
 
+      const formatElapsed = (totalSeconds) => {
+        const s = Math.max(0, Math.floor(Number(totalSeconds) || 0));
+        if (s < 60) return `${s}s`;
+        const m = Math.floor(s / 60);
+        const remS = s % 60;
+        if (m < 60) return remS > 0 ? `${m}m ${remS}s` : `${m}m`;
+        const h = Math.floor(m / 60);
+        const remM = m % 60;
+        return remM > 0 ? `${h}h ${remM}m` : `${h}h`;
+      };
+
       const formatLiveElapsed = () => {
 
         if (!state) return '0s';
@@ -3821,7 +3960,7 @@ window.__ModuleLoader__.load({
       const [updateState, setUpdateState] = useState({
         checking: false,
         updating: false,
-        currentVersion: '0.2.3',
+        currentVersion: '',
         latestVersion: '',
         updateAvailable: false,
         notice: '',
@@ -4159,7 +4298,7 @@ window.__ModuleLoader__.load({
                           'div',
                           { style: { display: 'flex', alignItems: 'center', gap: 8 } },
                           React.createElement('span', { style: { fontSize: 13, fontWeight: 500, color: 'var(--dsw-alias-label-primary)' } }, t('version') || 'Version'),
-                          React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'v' + (updateState.currentVersion || '0.2.3')),
+                          React.createElement('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, updateState.currentVersion ? 'v' + updateState.currentVersion : 'v0.2.12'),
                           updateState.updateAvailable
                             ? React.createElement('span', { className: 'dsh-goal-badge dsh-goal-badge-warn', style: { fontSize: 11 } }, 'v' + updateState.latestVersion + ' ' + (t('updateAvailable') || 'available'))
                             : React.createElement('span', { className: 'dsh-goal-badge dsh-goal-badge-ok', style: { fontSize: 11 } }, '✓ ' + (t('upToDate') || 'Up to date')),

package/lib/engine-reports.js

@@ -1,4 +1,8 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
 import { execFileSync } from 'node:child_process';
+import { generateRetrospectiveData } from './engine-retrospective.js';
 
 /**
  * Safely get current short git commit hash
@@ -19,48 +23,119 @@ export function getGitCurrentCommit(cwd) {
 }
 
 /**
- * Generate Markdown report for goal results
- * @param {Object} state
+ * Format elapsed time in human readable format
+ * @param {number} seconds
  * @returns {string}
  */
-export function exportReportMarkdown(state) {
-  if (!state) return '';
-  const title = state.title || 'Goal Report';
-  const status = state.state === 'COMPLETED' ? 'COMPLETED' : state.state;
-  const elapsed = state.formattedElapsed || '0s';
-  const iter = `${state.iterationsCount || 0}/${state.maxIterations || 25}`;
-  const totalTokens = state.tokensUsage?.totalTokens || 0;
-  const promptTokens = state.tokensUsage?.promptTokens || 0;
-  const compTokens = state.tokensUsage?.completionTokens || 0;
-  const gitCommit = state.gitStartCommit ? ` | **Git Start:** \`${state.gitStartCommit}\`` : '';
+export function formatElapsedSeconds(seconds) {
+  const s = Math.max(0, Math.floor(seconds || 0));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const remSec = s % 60;
+  if (m < 60) return `${m}m ${remSec}s`;
+  const h = Math.floor(m / 60);
+  const remMin = m % 60;
+  return `${h}h ${remMin}m`;
+}
+
+/**
+ * Generate Markdown report for goal completion or archival
+ * @param {object} goal - core goal view or state
+ * @param {object} [addonData] - { milestones, snapshots, tokensUsage }
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export function exportReportMarkdown(goal, addonData = {}, cwd = process.cwd()) {
+  if (!goal) return '';
+  const title = goal.objective || goal.title || 'Goal Report';
+  const phase = goal.phase || goal.state || 'COMPLETED';
+  const rounds = goal.roundsStarted || goal.iterationsCount || 0;
+  const maxRounds = goal.maxGoalRounds || goal.maxIterations || 25;
+
+  const elapsed = goal.formattedElapsed || formatElapsedSeconds(Math.max(0, Math.round(((goal.updatedAt || goal.completedAt || Date.now()) - (goal.createdAt || goal.startedAt || Date.now())) / 1000)));
+
+  const totalTokens = addonData?.tokensUsage?.totalTokens || goal?.tokensUsage?.totalTokens || 0;
+  const promptTokens = addonData?.tokensUsage?.promptTokens || goal?.tokensUsage?.promptTokens || 0;
+  const compTokens = addonData?.tokensUsage?.completionTokens || goal?.tokensUsage?.completionTokens || 0;
+  const gitCommit = goal.gitStartCommit ? ` | **Git Start:** \`${goal.gitStartCommit}\`` : '';
 
   let md = `# 🎯 Goal Report: ${title}\n\n`;
-  md += `**Status:** \`${status}\` | **Duration:** \`${elapsed}\` | **Iterations:** \`${iter}\`${gitCommit}\n`;
+  md += `**Status:** \`${phase}\` | **Duration:** \`${elapsed}\` | **Iterations:** \`${rounds}/${maxRounds}\`${gitCommit}\n`;
   if (totalTokens > 0) {
     md += `**Tokens:** \`${totalTokens.toLocaleString('en-US')}\` (Prompt: \`${promptTokens.toLocaleString('en-US')}\`, Completion: \`${compTokens.toLocaleString('en-US')}\`)\n`;
   }
   md += '\n';
 
-  if (state.description) {
-    md += `### Description\n${state.description}\n\n`;
+  if (goal.description) {
+    md += `### Description\n${goal.description}\n\n`;
   }
 
-  if (state.resultSummary) {
-    md += `### Summary & Deliverables\n${state.resultSummary}\n\n`;
+  if (goal.resultSummary) {
+    md += `### Summary & Deliverables\n${goal.resultSummary}\n\n`;
   }
 
-  const milestones = state.milestones || [];
+  // Milestones & Checklists
+  const milestones = addonData?.milestones || goal?.milestones || [];
   if (milestones.length > 0) {
-    md += `### Milestones\n| # | Status | Title | Notes |\n|---|---|---|---|\n`;
+    md += `### Milestones & Checklists\n`;
+    md += `| # | Status | Title | Notes | Checklists |\n`;
+    md += `|---|---|---|---|---|\n`;
     milestones.forEach((m, idx) => {
-      const mark = m.status === 'completed' ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
+      const isDone = m.status === 'completed' || m.completed === true;
+      const isInProg = m.status === 'in_progress';
+      const mark = isDone ? '✅ Done' : isInProg ? '🔄 In Progress' : '⏳ Pending';
       const cleanTitle = (m.title || '').replace(/\|/g, '\\|');
-      const cleanNotes = (m.notes || '').replace(/\|/g, '\\|');
-      md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes || '—'} |\n`;
+      const cleanNotes = (m.notes || '—').replace(/\|/g, '\\|');
+      let clSummary = '—';
+      if (Array.isArray(m.checklist) && m.checklist.length > 0) {
+        const doneCount = m.checklist.filter(c => c.done).length;
+        clSummary = `${doneCount}/${m.checklist.length}`;
+      }
+      md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes} | ${clSummary} |\n`;
     });
     md += '\n';
   }
 
+  // Snapshots
+  const snapshots = addonData?.snapshots || [];
+  if (snapshots.length > 0) {
+    md += `### Git Checkpoints & Snapshots\n`;
+    md += `| Milestone | Commit | Tag | Timestamp |\n`;
+    md += `|---|---|---|---|\n`;
+    snapshots.forEach((s) => {
+      const dt = new Date(s.timestamp || Date.now()).toISOString();
+      md += `| \`${s.milestoneId}\` | \`${s.commit}\` | \`${s.tag || '—'}\` | ${dt} |\n`;
+    });
+    md += '\n';
+  }
+
+  // Retrospective
+  try {
+    const retro = generateRetrospectiveData({
+      ...goal,
+      milestones,
+      tokensUsage: { totalTokens, promptTokens, completionTokens },
+      startedAt: goal.createdAt || goal.startedAt || Date.now(),
+      completedAt: goal.updatedAt || goal.completedAt || Date.now(),
+    }, cwd);
+    if (retro) {
+      md += `### Retrospective & Execution Analytics\n`;
+      if (retro.estimatedCostUsd) {
+        md += `- **Estimated Cost:** ~\$${retro.estimatedCostUsd} USD\n`;
+      }
+      if (retro.filesChangedCount !== undefined) {
+        md += `- **Files Changed:** ${retro.filesChangedCount}\n`;
+      }
+      if (retro.recommendations?.length > 0) {
+        md += `\n**Recommendations:**\n`;
+        retro.recommendations.forEach(r => { md += `- ${r}\n`; });
+      }
+      md += '\n';
+    }
+  } catch (err) {
+    // Retrospective non-fatal
+  }
+
   md += `*Generated by DSH Goal Engine at ${new Date().toISOString()}*\n`;
   return md;
 }
@@ -72,10 +147,10 @@ export function exportReportMarkdown(state) {
  */
 export function exportReportGitHubPR(state) {
   if (!state) return '';
-  const title = state.title || 'Goal Report';
-  const status = state.state === 'COMPLETED' ? 'COMPLETED' : state.state;
+  const title = state.objective || state.title || 'Goal Report';
+  const status = state.phase || state.state || 'COMPLETED';
   const elapsed = state.formattedElapsed || '0s';
-  const iter = `${state.iterationsCount || 0}/${state.maxIterations || 25}`;
+  const iter = `${state.roundsStarted || state.iterationsCount || 0}/${state.maxGoalRounds || state.maxIterations || 25}`;
   const totalTokens = state.tokensUsage?.totalTokens || 0;
   const promptTokens = state.tokensUsage?.promptTokens || 0;
   const compTokens = state.tokensUsage?.completionTokens || 0;
@@ -97,11 +172,11 @@ export function exportReportGitHubPR(state) {
 
   const milestones = state.milestones || [];
   if (milestones.length > 0) {
-    const completedCount = milestones.filter((m) => m.status === 'completed').length;
+    const completedCount = milestones.filter((m) => m.status === 'completed' || m.completed === true).length;
     md += `<details>\n<summary><b>📋 Milestones Breakdown (${completedCount}/${milestones.length} Completed)</b></summary>\n\n`;
     md += `| # | Status | Milestone | Notes |\n|---|---|---|---|\n`;
     milestones.forEach((m, idx) => {
-      const mark = m.status === 'completed' ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
+      const mark = (m.status === 'completed' || m.completed === true) ? '✅ Done' : m.status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending';
       const cleanTitle = (m.title || '').replace(/\|/g, '\\|');
       const cleanNotes = (m.notes || '').replace(/\|/g, '\\|');
       md += `| ${idx + 1} | ${mark} | ${cleanTitle} | ${cleanNotes || '—'} |\n`;
@@ -113,9 +188,6 @@ export function exportReportGitHubPR(state) {
   return md;
 }
 
-import fs from 'node:fs';
-import path from 'node:path';
-
 /**
  * Safely create a git milestone checkpoint
  * @param {object} milestone
@@ -133,7 +205,6 @@ export function createMilestoneCheckpoint(milestone, sessionId = 'default', cwd)
       cwd: cwd || undefined,
     }).trim();
 
-    // If there are changes, auto-commit checkpoint
     if (status) {
       execFileSync('git', ['add', '-A'], {
         stdio: ['ignore', 'ignore', 'ignore'],
@@ -191,7 +262,7 @@ export function rollbackToCheckpoint(commitHash, cwd) {
  * @returns {{ relativePath: string, fullPath: string, content: string }|null}
  */
 export function saveGoalArtifact(state, cwd) {
-  if (!state || !state.title) return null;
+  if (!state || (!state.title && !state.objective)) return null;
   try {
     const root = cwd || process.cwd();
     const targetDir = path.join(root, '.dsh', 'goals');
@@ -200,7 +271,7 @@ export function saveGoalArtifact(state, cwd) {
     }
 
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const safeTitle = (state.title || 'goal')
+    const safeTitle = (state.objective || state.title || 'goal')
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, '-')
       .replace(/^-+|-+$/g, '')
@@ -218,3 +289,11 @@ export function saveGoalArtifact(state, cwd) {
     return null;
   }
 }
+
+/**
+ * Save goal report to disk
+ */
+export function saveGoalReportFile(goal, addonData = {}, baseDir = null) {
+  const root = baseDir || process.cwd();
+  return saveGoalArtifact(goal, root)?.fullPath || null;
+}

package/lib/engine-store.js

@@ -6,9 +6,10 @@ import { GoalState } from './goal-engine-constants.js';
  * Storage manager for goal engine disk state persistence
  */
 export class EngineStore {
-  constructor(engine, storagePath) {
+  constructor(engine, storagePath, logger) {
     this.engine = engine;
     this.storagePath = storagePath || null;
+    this.logger = logger || engine?.logger || console;
     this.saveTimer = null;
   }
 
@@ -77,7 +78,7 @@ export class EngineStore {
       }
     } catch (err) {
       // best-effort load failure logged defensively
-      console.warn?.('[GoalEngine] Failed to load state from disk:', err?.message || err);
+      this.logger?.warn?.('[GoalEngine] Failed to load state from disk:', err?.message || err);
     }
   }
 
@@ -128,7 +129,7 @@ export class EngineStore {
       fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
       fs.renameSync(tmp, this.storagePath);
     } catch (err) {
-      console.warn?.('[GoalEngine] Failed to write state to disk:', err?.message || err);
+      this.logger?.warn?.('[GoalEngine] Failed to write state to disk:', err?.message || err);
     }
   }