dw-kit 1.8.0-rc.2 → 1.9.0

package/src/lib/event-schema.mjs

@@ -0,0 +1,342 @@
+// event-schema.mjs — runtime validator for the DW Event Schema v1.0.
+//
+// Authoritative spec: docs/specs/dw-event-schema-v1.0.md
+// Adapter protocol:   docs/specs/dw-adapter-protocol.md
+//
+// Design choices:
+//   - Hand-rolled validator, no ajv dependency at the hot path. The schemas
+//     are small (≤8 fields per event), the validator runs per-event in
+//     every adapter, and zero-dep keeps the npm install footprint flat.
+//     ajv-validated JSON Schema files DO ship (under .dw/core/schemas/events/)
+//     for third-party tools, but dw-kit itself uses this code path.
+//   - Advisory by default. validateEvent() returns { ok, errors }; it does
+//     NOT throw. Writers must not lose audit data due to a schema bug —
+//     the validator is for adapters at the boundary, not for the producer.
+//   - Tolerant of unknown event names + unknown fields. Per §8 of the spec,
+//     adapters MUST tolerate forward-compat additions; this validator
+//     mirrors that posture (an unknown event_name returns { ok: true,
+//     warnings: ['unknown event name; treated as informational'] }).
+//
+// Per ADR-0001: zero-dep, Node built-ins only.
+
+export const SCHEMA_VERSION = '1.0.0';
+
+// Catalogue of known event names, grouped by category (matches §5 of the
+// spec). The value is the field shape: { required: [...], optional: [...] }.
+// Field names map to type validators in TYPE_VALIDATORS below.
+export const EVENT_CATALOGUE = {
+  // §5.1 Session lifecycle
+  created: {
+    category: 'session-lifecycle',
+    required: { agent: 'string', goal: 'string' },
+    optional: {},
+  },
+  started: {
+    category: 'session-lifecycle',
+    required: { pid: 'int', command: 'string', via: 'enum:cli|voice|voice-action|connector' },
+    optional: { args: 'string[]', goal_mode: 'enum:stdin|trailing-arg', workspace: 'string' },
+  },
+  stopped: {
+    category: 'session-lifecycle',
+    required: { signal: 'string', by: 'string' },
+    optional: {},
+  },
+  reconciled: {
+    category: 'session-lifecycle',
+    required: { reason: 'string' },
+    optional: {},
+  },
+  reconciled_stale: {
+    category: 'session-lifecycle',
+    required: { by: 'string' },
+    optional: {},
+  },
+  spawn_failed: {
+    category: 'session-lifecycle',
+    required: { error: 'string' },
+    optional: {},
+  },
+
+  // §5.2 Voice orchestrator
+  orchestrator_started: {
+    category: 'voice-orchestrator',
+    required: { transcript_preview: 'string', agent: 'string' },
+    optional: {},
+  },
+  orchestrator_spawn_failed: {
+    category: 'voice-orchestrator',
+    required: { error: 'string' },
+    optional: {},
+  },
+  orchestrator_timeout: {
+    category: 'voice-orchestrator',
+    required: { timeout_ms: 'int' },
+    optional: {},
+  },
+  orchestrator_completed: {
+    category: 'voice-orchestrator',
+    required: { exit_code: 'int' },
+    optional: { reply_chars: 'int', stderr_chars: 'int', reply_preview: 'string' },
+  },
+  orchestrator_error: {
+    category: 'voice-orchestrator',
+    required: { error: 'string' },
+    optional: {},
+  },
+
+  // §5.3 Voice action gate (ADR-0014)
+  orchestrator_recommended: {
+    category: 'voice-action',
+    required: { action: 'string', args: 'object' },
+    optional: {},
+  },
+  orchestrator_recommend_rejected: {
+    category: 'voice-action',
+    required: { action: 'string', args: 'object', error: 'string' },
+    optional: {},
+  },
+  orchestrator_confirm: {
+    category: 'voice-action',
+    required: { action: 'string', args: 'object' },
+    optional: {},
+  },
+  orchestrator_confirmed: {
+    category: 'voice-action',
+    required: { action: 'string', args: 'object' },
+    optional: {}, // result fields vary by action; tolerate any extras
+  },
+  orchestrator_cancelled: {
+    category: 'voice-action',
+    required: { action: 'string' },
+    optional: {},
+  },
+  orchestrator_pending_dropped: {
+    category: 'voice-action',
+    required: { action: 'string' },
+    optional: {},
+  },
+  orchestrator_pending_expired: {
+    category: 'voice-action',
+    required: { action: 'string' },
+    optional: { ttl_ms: 'int' },
+  },
+
+  // §5.4 Multi-agent debate (ADR-0015)
+  debate_started: {
+    category: 'debate',
+    required: { debate_id: 'string', topic: 'string', roster: 'string[]', lang: 'string' },
+    optional: { audit_session_id: 'string' },
+  },
+  debate_agent_started: {
+    category: 'debate',
+    required: { debate_id: 'string', agent: 'string', pid: 'int' },
+    optional: {},
+  },
+  debate_agent_replied: {
+    category: 'debate',
+    required: { debate_id: 'string', agent: 'string', ms: 'int', reply: 'string' },
+    optional: { reply_chars: 'int' },
+  },
+  debate_agent_failed: {
+    category: 'debate',
+    required: { debate_id: 'string', agent: 'string' },
+    optional: { error: 'string', exit_code: 'int', ms: 'int' },
+  },
+  debate_completed: {
+    category: 'debate',
+    required: { debate_id: 'string', agents: 'string[]' },
+    optional: {},
+  },
+
+  // §5.4b Session lifecycle — GLOBAL sink (F-44, lightweight signals for SSE
+  // fanout to dashboards). These are dual-written from session-store.mjs; the
+  // per-session events.jsonl still carries the full audit (created/started/
+  // stopped/reconciled). The `session.*` prefix differentiates global signals
+  // from per-session detail.
+  'session.created': {
+    category: 'session-lifecycle',
+    required: { session_id: 'string', agent: 'string' },
+    optional: { goal: 'string', workspace_path: 'string' },
+  },
+  'session.status_changed': {
+    category: 'session-lifecycle',
+    required: { session_id: 'string', to_status: 'string' },
+    optional: { from_status: 'string', pid: 'int', exit_code: 'int' },
+  },
+  'session.reconciled': {
+    category: 'session-lifecycle',
+    required: { session_id: 'string', reason: 'string' },
+    optional: {},
+  },
+
+  // §5.5 Goal layer
+  goal_created: {
+    category: 'goal',
+    required: { goal_id: 'string' },
+    optional: { created_by: 'string' },
+  },
+  goal_field_updated: {
+    category: 'goal',
+    required: { goal_id: 'string', field: 'string' },
+    optional: { old: 'any', new: 'any' },
+  },
+  goal_status_changed: {
+    category: 'goal',
+    required: { goal_id: 'string', from_status: 'string', to_status: 'string' },
+    optional: { changed_by: 'string' },
+  },
+  goal_pivoted: {
+    category: 'goal',
+    required: { goal_id: 'string', from_version: 'int' },
+    optional: { to_version: 'int' },
+  },
+  goal_archived: {
+    category: 'goal',
+    required: { goal_id: 'string' },
+    optional: { archived_at: 'string' },
+  },
+  goal_task_linked: {
+    category: 'goal',
+    required: { goal_id: 'string', task_id: 'string' },
+    optional: {},
+  },
+  goal_task_unlinked: {
+    category: 'goal',
+    required: { goal_id: 'string', task_id: 'string' },
+    optional: {},
+  },
+};
+
+export const KNOWN_EVENTS = Object.freeze(Object.keys(EVENT_CATALOGUE));
+export const CATEGORIES = Object.freeze(
+  Array.from(new Set(Object.values(EVENT_CATALOGUE).map((s) => s.category)))
+);
+
+// ─ Type validators ──────────────────────────────────────────────────────────
+
+function isInt(v) { return typeof v === 'number' && Number.isInteger(v) && Number.isFinite(v); }
+function isString(v) { return typeof v === 'string'; }
+function isStringArray(v) { return Array.isArray(v) && v.every(isString); }
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function validateField(value, type) {
+  // 'any' = present (not undefined). 'object' = plain object. 'enum:a|b|c' = one of.
+  if (type === 'any') return value !== undefined;
+  if (type === 'int') return isInt(value);
+  if (type === 'string') return isString(value);
+  if (type === 'string[]') return isStringArray(value);
+  if (type === 'object') return isPlainObject(value);
+  if (type.startsWith('enum:')) {
+    const allowed = type.slice(5).split('|');
+    return isString(value) && allowed.includes(value);
+  }
+  return false;
+}
+
+// ─ Envelope validation ─────────────────────────────────────────────────────
+
+function validateEnvelope(ev) {
+  const errors = [];
+  if (!isPlainObject(ev)) {
+    errors.push('event must be a JSON object');
+    return errors;
+  }
+  if (!isString(ev.ts) || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(ev.ts)) {
+    errors.push('envelope.ts must be ISO 8601 UTC string ending in Z');
+  }
+  // F-44: allow dotted namespace prefix for global-sink events (e.g.
+  // session.created, goal.archived) per the v1.1 catalogue additions. The
+  // legacy bare snake_case names (created, debate_started, ...) remain valid.
+  if (!isString(ev.event) || !/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)?$/.test(ev.event)) {
+    errors.push('envelope.event must be lowercase snake_case (optional dotted namespace prefix)');
+  }
+  return errors;
+}
+
+// ─ Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Validate a single event. Returns { ok, errors, warnings, category? }.
+ *
+ * - Unknown event names → ok: true, warnings: ['unknown event name'],
+ *   category: 'unknown'. Per spec §8, adapters MUST tolerate unknown events.
+ * - Unknown fields on known events → ok: true. Per spec §8, adapters MUST
+ *   tolerate unknown fields.
+ * - Missing required fields → ok: false.
+ * - Type mismatches on known fields → ok: false.
+ * - Missing/malformed envelope → ok: false.
+ *
+ * Never throws. Returns plain data.
+ */
+export function validateEvent(ev) {
+  const errors = validateEnvelope(ev);
+  const warnings = [];
+
+  if (errors.length > 0) {
+    return { ok: false, errors, warnings, category: null };
+  }
+
+  const spec = EVENT_CATALOGUE[ev.event];
+  if (!spec) {
+    return {
+      ok: true,
+      errors: [],
+      warnings: [`unknown event name "${ev.event}"; treated as informational per spec §8`],
+      category: 'unknown',
+    };
+  }
+
+  for (const [name, type] of Object.entries(spec.required)) {
+    if (!(name in ev)) {
+      errors.push(`required field "${name}" missing`);
+      continue;
+    }
+    if (!validateField(ev[name], type)) {
+      errors.push(`field "${name}" failed type check (${type})`);
+    }
+  }
+
+  for (const [name, type] of Object.entries(spec.optional || {})) {
+    if (!(name in ev)) continue;
+    if (!validateField(ev[name], type)) {
+      errors.push(`optional field "${name}" present but failed type check (${type})`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    category: spec.category,
+  };
+}
+
+/**
+ * Throwing variant. Use at adapter boundaries when you want strict
+ * enforcement. Throws a single Error whose .message lists all problems.
+ */
+export function validateEventStrict(ev) {
+  const r = validateEvent(ev);
+  if (!r.ok) {
+    const e = new Error(`event failed strict validation: ${r.errors.join('; ')}`);
+    e.errors = r.errors;
+    e.event = ev;
+    throw e;
+  }
+  return r;
+}
+
+/**
+ * Filter an event stream to only those passing validation. Yields the
+ * survivors. Logs skipped events to the supplied `onSkip` callback if
+ * provided. Used by adapter tail-readers per protocol §4 rule 1.
+ */
+export function* filterValid(events, onSkip) {
+  for (const ev of events) {
+    const r = validateEvent(ev);
+    if (r.ok) yield ev;
+    else if (typeof onSkip === 'function') onSkip(ev, r.errors);
+  }
+}

package/src/lib/goal-store.mjs

@@ -38,15 +38,35 @@ export function readGoalIndex(rootDir = process.cwd()) {
   }
 }
 
+// Stable key order so the same goal set serializes byte-identically regardless
+// of writer path (syncIndexEntry appends; rebuilds use readdirSync order) (#21).
+function sortGoals(goals) {
+  const sorted = {};
+  for (const id of Object.keys(goals || {}).sort()) sorted[id] = goals[id];
+  return sorted;
+}
+
 export function writeGoalIndex(index, rootDir = process.cwd()) {
   const file = goalIndexFile(rootDir);
   const dir = dirname(file);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const goals = sortGoals(index.goals);
+  // Skip the write when the goal set is byte-identical to disk: preserves the
+  // on-disk last_updated (freshness signal, ADR-0017/0018) and yields zero diff.
+  const prior = readGoalIndex(rootDir);
+  if (existsSync(file) && JSON.stringify(sortGoals(prior.goals)) === JSON.stringify(goals)) {
+    return prior;
+  }
+  // Spread `index` first so non-payload top-level fields ($schema_note,
+  // schema_version) and their order are preserved; override goals (sorted) +
+  // last_updated in place.
   const updated = {
     ...index,
     last_updated: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
+    goals,
   };
   writeFileSync(file, JSON.stringify(updated, null, 2) + '\n', 'utf8');
+  return updated;
 }
 
 export function readGoal(goalId, rootDir = process.cwd()) {
@@ -181,7 +201,9 @@ export function findLinkedTaskIds(goalId, rootDir = process.cwd()) {
       else if (Array.isArray(fm.contributing_goal_ids) && fm.contributing_goal_ids.includes(goalId)) linked.push(entry);
     } catch { /* skip */ }
   }
-  return linked;
+  // Sort for determinism — readdirSync order is filesystem-dependent and would
+  // otherwise churn linked_task_ids in the committed index (#21).
+  return linked.sort();
 }
 
 function extractTitle(content) {
@@ -200,3 +222,20 @@ export function nowUtc() {
 export function validateGoalId(goalId) {
   return /^G-[A-Za-z0-9](?:[A-Za-z0-9.-]{0,31}[A-Za-z0-9])?$/.test(goalId);
 }
+
+// Single source for the goal lifecycle status enum (#20). Reads the project's
+// schema (consumer-vendored via `dw init`) and falls back to the canonical set
+// when absent, so the status command works in a stripped install.
+const FALLBACK_GOAL_STATUSES = ['Draft', 'Active', 'Achieved', 'Abandoned', 'Pivoted'];
+
+export function goalStatusEnum(rootDir = process.cwd()) {
+  const schemaFile = join(rootDir, '.dw/core/schemas/goal-frontmatter.schema.json');
+  if (!existsSync(schemaFile)) return [...FALLBACK_GOAL_STATUSES];
+  try {
+    const schema = JSON.parse(readFileSync(schemaFile, 'utf8'));
+    const enumVals = schema?.properties?.status?.enum;
+    return Array.isArray(enumVals) && enumVals.length ? enumVals : [...FALLBACK_GOAL_STATUSES];
+  } catch {
+    return [...FALLBACK_GOAL_STATUSES];
+  }
+}

package/src/lib/lint-rules.mjs

@@ -44,10 +44,19 @@ export function lintTimeline(taskDir, opts = {}) {
     const result = validateFrontmatter(fm, schema);
     if (!result.ok) {
       for (const e of result.errors) {
+        let message = `${e.path}: ${e.message}${e.keyword ? ` (${e.keyword})` : ''}`;
+        // #22: the raw ajv enum error for schema_version is opaque. Teach the
+        // allowed values + the namespaced-vs-bare convention right at the error.
+        if (e.path === '/schema_version' && e.keyword === 'enum') {
+          const allowed = (e.params?.allowedValues || []).map((v) => `"${v}"`).join(', ');
+          message = `schema_version: must be one of ${allowed}. Canonical is namespaced `
+            + `(task@v3.x) to match goal@v1 / tasks-index@v1; bare v3.x stays valid for `
+            + `back-compat. See docs/specs/dw-document-schema-v1.0.md §2.1.`;
+        }
         violations.push({
           severity: 'error',
           rule: 'frontmatter-schema',
-          message: `${e.path}: ${e.message}${e.keyword ? ` (${e.keyword})` : ''}`,
+          message,
           file: timelineFile,
         });
       }

package/src/lib/orchestrator.mjs

@@ -96,12 +96,32 @@ export function collectContext(rootDir, transcript = '', lang = 'en-US') {
  * ctx.lang (BCP-47, e.g. "vi-VN", "en-US") tells the agent which language
  * the user is most likely speaking; agent replies in that language.
  */
+// F-48 Deep mode trigger detection. User says "explain X" / "phân tích X" /
+// "đi sâu" etc → orchestrator answers with longer detail (≤8 sentences,
+// markdown allowed); TTS still reads only the head, page shows full reply.
+const DEEP_PATTERNS_EN = /\b(explain|elaborate|deep dive|thoroughly|in detail|tell me more|walk me through|break down|analyz[se])\b/i;
+// VN: drop \b (JS regex word boundary doesn't recognize Vietnamese diacritics
+// as word chars without /u + \p{L}). The phrases are distinctive enough that
+// substring match is safe.
+const DEEP_PATTERNS_VI = /(phân tích|chi tiết|giải thích kỹ|đi sâu|nói rõ|kỹ hơn|chi tiet|phan tich)/i;
+export function detectDeepMode(text, lang = 'en-US') {
+  if (typeof text !== 'string' || !text) return false;
+  if (lang.startsWith('vi') && DEEP_PATTERNS_VI.test(text)) return true;
+  return DEEP_PATTERNS_EN.test(text);
+}
+
 export function getOrchestratorPrompt(ctx = {}) {
   const transcriptSafe = (ctx.transcript || '').slice(0, 2000).replace(/"/g, '\\"');
   const lang = ctx.lang || 'en-US';
   const langPrefix = lang.split('-')[0];
+  const deep = ctx.mode === 'deep';
+  const lengthRule = deep
+    ? (langPrefix === 'vi'
+        ? `- DEEP MODE: trả lời chi tiết (≤8 câu), markdown OK. TTS sẽ chỉ đọc câu đầu, browser sẽ hiển thị toàn bộ.`
+        : `- DEEP MODE: reply in detail (≤8 sentences), markdown OK. TTS will read the head only; browser shows the full reply.`)
+    : `- Reply in <=2 sentences before the tag. TTS reads slowly; brevity is kindness.`;
   const langLine = langPrefix === 'vi'
-    ? `- The user is speaking Vietnamese (${lang}). REPLY IN VIETNAMESE. Vẫn theo các quy tắc trên: <=2 câu, không preamble.`
+    ? `- The user is speaking Vietnamese (${lang}). REPLY IN VIETNAMESE. ${deep ? 'Cho phép markdown + ≤8 câu (DEEP MODE).' : 'Vẫn theo các quy tắc trên: <=2 câu, không preamble.'}`
     : `- The user is speaking ${lang}. Reply in that language unless they switch.`;
   const prompt = [
     `You are a voice orchestrator for dw, a CLI workflow toolkit.`,
@@ -123,8 +143,9 @@ export function getOrchestratorPrompt(ctx = {}) {
     `    [ACTION: start_session agent=claude goal="fix the bug"]`,
     `    [ACTION: prune_sessions days=7]`,
     `  The system will ask the user to confirm before executing. ONLY these 3 actions are whitelisted; for any other request just answer verbally.`,
+    `- F-43: When the user asks to "start an agent FOR a goal" / "khởi động agent cho goal X" / "tiếp tục goal X" / "resume goal X", the goal= arg MUST be a FULL TASK PROMPT, not just the goal_id. Example BAD: goal="G-rgoal-realtime-orch". Example GOOD: goal="Read .dw/goals/G-rgoal-realtime-orch/goal.md, find the linked task, pick the first pending subtask in Section 3, execute it (TDD), commit per repo rules, stop before push." A bare goal_id makes the spawned agent give a one-shot status report instead of actually working. (The system will safety-net-expand a bare goal_id, but it's better to write the full prompt yourself.)`,
     `- For READ-ONLY queries (listing sessions / listing goals / showing one session's details / checking status / "what's running" / "how many goals"), DO NOT emit an action tag. You ALREADY have the workspace state above — summarize it directly in your reply. Inventing actions like "list_sessions" or "show_status" is a bug; just answer with the data you see.`,
-    `- Reply in <=2 sentences before the tag. TTS reads slowly; brevity is kindness.`,
+    lengthRule,
     `- Skip preamble ("Sure, ...", "Here's ..."). Answer directly.`,
     `- If the user is chatting socially, NO tag — just chat briefly + nudge toward a command.`,
     `- If you don't know, say so — don't invent commands or actions that aren't in the list above.`,
@@ -159,19 +180,20 @@ export function getOrchestratorPrompt(ctx = {}) {
  *
  * Returns: { ok, reply?, error?, sessionId?, exitCode? }
  */
-export async function runOrchestrator({ text, rootDir, agentName, timeoutMs = DEFAULT_TIMEOUT_MS, lang = 'en-US' }) {
+export async function runOrchestrator({ text, rootDir, agentName, timeoutMs = DEFAULT_TIMEOUT_MS, lang = 'en-US', mode = 'quick' }) {
   const cfg = loadAgentsConfig(rootDir);
   const def = cfg.agents?.[agentName];
   if (!def || !def.command) {
     return { ok: false, error: `orchestrator agent "${agentName}" not configured in agents.yml` };
   }
-  const ctx = collectContext(rootDir, text, lang);
+  // F-48: 'deep' mode loosens the ≤2-sentence rule.
+  const ctx = { ...collectContext(rootDir, text, lang), mode };
   const prompt = getOrchestratorPrompt(ctx);
 
   // Build argv. `goal_mode` is the same conventions as `dw session start`.
   const args = [...(def.args || [])];
-  const mode = def.goal_mode || 'trailing-arg';
-  if (mode === 'trailing-arg') args.push(prompt);
+  const goalMode = def.goal_mode || 'trailing-arg';
+  if (goalMode === 'trailing-arg') args.push(prompt);
   // For stdin mode we write below after spawn.
 
   // Audit session (lightweight — we don't redirect stdio to file; capture inline).
@@ -179,7 +201,7 @@ export async function runOrchestrator({ text, rootDir, agentName, timeoutMs = DE
     agent: `voice-orchestrator:${agentName}`,
     goal: text.slice(0, 200),
     workspacePath: rootDir,
-    command: [def.command, ...args.slice(0, args.length - (mode === 'trailing-arg' ? 1 : 0))],
+    command: [def.command, ...args.slice(0, args.length - (goalMode === 'trailing-arg' ? 1 : 0))],
   }, rootDir);
   appendEvent(state.session_id, { event: 'orchestrator_started', transcript_preview: text.slice(0, 120), agent: agentName }, rootDir);
 
@@ -199,7 +221,7 @@ export async function runOrchestrator({ text, rootDir, agentName, timeoutMs = DE
     try {
       child = spawnAgent(resolved, args, {
         cwd: rootDir,
-        stdio: [mode === 'stdin' ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+        stdio: [goalMode === 'stdin' ? 'pipe' : 'ignore', 'pipe', 'pipe'],
         env: { ...process.env, ...(def.env || {}) },
         windowsHide: true,
       });
@@ -224,7 +246,7 @@ export async function runOrchestrator({ text, rootDir, agentName, timeoutMs = DE
     child.stdout.on('data', (c) => { stdout += c.toString(); });
     child.stderr.on('data', (c) => { stderr += c.toString(); });
 
-    if (mode === 'stdin') {
+    if (goalMode === 'stdin') {
       try { child.stdin.write(prompt + '\n'); child.stdin.end(); } catch { /* harmless */ }
     }
 

package/src/lib/session-store.mjs

@@ -23,6 +23,11 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, appendFileSync, openSync, closeSync, renameSync, rmSync, statSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
 import { randomBytes } from 'node:crypto';
+// F-44: dual-write session lifecycle signals to events-global.jsonl so the
+// SSE broker can fan them to browser/adapter clients for realtime updates.
+// Per-session events.jsonl remains the authoritative audit; the global
+// signals are intentionally lightweight (session_id + transition only).
+import { logGoalEvent } from './goal-events.mjs';
 
 const SESSIONS_DIR = '.dw/cache/sessions';
 
@@ -200,6 +205,17 @@ export function createSession({ agent, goal, workspacePath, command, owner }, ro
 
   appendEvent(sessionId, { event: 'created', agent, goal }, rootDir);
 
+  // F-44: dual-write a lightweight global signal so SSE clients refresh.
+  try {
+    logGoalEvent({
+      event: 'session.created',
+      session_id: sessionId,
+      agent,
+      goal: typeof goal === 'string' ? goal.slice(0, 120) : '',
+      workspace_path: state.workspace_path,
+    }, rootDir);
+  } catch { /* best-effort; per-session events.jsonl is authoritative */ }
+
   const idx = loadIndex(rootDir);
   idx.sessions[sessionId] = summarize(state);
   saveIndex(rootDir, idx);
@@ -231,6 +247,20 @@ export function updateSessionStatus(sessionId, patch, rootDir = process.cwd()) {
   const idx = loadIndex(rootDir);
   idx.sessions[sessionId] = summarize(merged);
   saveIndex(rootDir, idx);
+
+  // F-44: dual-write a lightweight global signal when status actually changed.
+  if (patch.status && patch.status !== state.status) {
+    try {
+      logGoalEvent({
+        event: 'session.status_changed',
+        session_id: sessionId,
+        from_status: state.status,
+        to_status: patch.status,
+        ...(typeof merged.pid === 'number' ? { pid: merged.pid } : {}),
+        ...(typeof merged.exit_code === 'number' ? { exit_code: merged.exit_code } : {}),
+      }, rootDir);
+    } catch { /* best-effort */ }
+  }
   return merged;
 }
 
@@ -272,10 +302,12 @@ export function reconcileStaleSessions(rootDir = process.cwd()) {
     const pidMissing = !summary.pid;
     if (pidDead || pidMissing) {
       updateSessionStatus(id, { status: 'exited', pid: null }, rootDir);
-      appendEvent(id, {
-        event: 'reconciled',
-        reason: pidMissing ? 'missing-pid' : 'pid-dead-on-listing',
-      }, rootDir);
+      const reason = pidMissing ? 'missing-pid' : 'pid-dead-on-listing';
+      appendEvent(id, { event: 'reconciled', reason }, rootDir);
+      // F-44: also fan global signal so SSE-watching clients refresh.
+      try {
+        logGoalEvent({ event: 'session.reconciled', session_id: id, reason }, rootDir);
+      } catch { /* best-effort */ }
       changed++;
     }
   }