@karmaniverous/jeeves-meta 0.16.2 → 0.17.0

package/README.md

@@ -19,7 +19,7 @@ HTTP service for the Jeeves knowledge synthesis engine. Provides a Fastify API,
 - **Virtual rule registration** — registers 3 watcher inference rules at startup with retry
 - **Progress reporting** — real-time synthesis events via gateway channel messages
 - **Graceful shutdown** — stop scheduler, release locks, close server
-- **Built-in prompts** — default architect and critic prompts ship with the package; optional config overrides via `@file:` or inline strings
+- **Built-in prompts** — default architect and critic prompts ship with the package
 - **Handlebars templates** — prompts compiled with `{ config, meta, scope }` context; architect can write template expressions into builder briefs
 - **Config hot-reload** — all synthesis parameters reload without restart; restart-required fields (port, URLs) warn on change
 - **Auto-seed policy** — config-driven declarative `.meta/` creation via `autoSeed` rules

package/dist/cli/jeeves-meta/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { sleepAsync, createConfigQueryHandler, atomicWrite, createStatusHandler, getBindAddress, fetchJson, postJson, getServiceUrl, jeevesComponentDescriptorSchema, createServiceCli } from '@karmaniverous/jeeves';
+import { sleepAsync, fetchWithTimeout, createConfigQueryHandler, atomicWrite, createStatusHandler, getBindAddress, fetchJson, postJson, getServiceUrl, jeevesComponentDescriptorSchema, createServiceCli } from '@karmaniverous/jeeves';
 import { normalizePath, metaConfigSchema, getEndpoint, META_COMPONENT } from '@karmaniverous/jeeves-meta-core';
 import fs, { unlinkSync, writeFileSync, existsSync, readFileSync, statSync, mkdirSync, readdirSync, watchFile } from 'node:fs';
 import path, { join, dirname, relative, posix, resolve } from 'node:path';
@@ -714,8 +714,6 @@ const RESTART_REQUIRED_FIELDS = [
     'watcherUrl',
     'gatewayUrl',
     'gatewayApiKey',
-    'defaultArchitect',
-    'defaultCritic',
 ];
 let runtime = null;
 /** Register the active service runtime for config-apply hot reload. */
@@ -765,6 +763,12 @@ function applyHotReloadedConfig(newConfig) {
  *
  * @module schema/config
  */
+/** Default Handlebars template strings for progress reporting. Single source of truth. */
+const DEFAULT_TEMPLATE_STRINGS = {
+    phaseStart: ':gear: Started meta synthesis {{phase}} phase of <{{dirLink}}>',
+    phaseEnd: ':white_check_mark: Completed meta synthesis {{phase}} phase ({{tokens}} tokens / {{seconds}}s) at <{{metaLink}}>',
+    phaseError: ':x: Meta synthesis {{phase}} phase failed at <{{dirLink}}>\n   Error: {{error}}',
+};
 /** Zod schema for logging configuration. */
 const loggingSchema = z.object({
     /** Log level. */
@@ -793,8 +797,24 @@ const serviceConfigSchema = metaConfigSchema.extend({
     reportChannel: z.string().optional(),
     /** Channel/user ID to send progress messages to. */
     reportTarget: z.string().optional(),
-    /** Optional base URL for the service, used to construct entity links in progress reports. */
-    serverBaseUrl: z.string().optional(),
+    /**
+     * URL of the local jeeves-server instance, used by the ProgressReporter
+     * to resolve filesystem paths to browse links via the resolve-path API.
+     * Default: http://127.0.0.1:1934
+     */
+    serverUrl: z.string().default('http://127.0.0.1:1934'),
+    /**
+     * Handlebars templates for progress reporting messages.
+     * Each template receives a standard set of data keys (dirLink, metaLink,
+     * phase, tokens, seconds, error).
+     */
+    templates: z
+        .object({
+        phaseStart: z.string().default(DEFAULT_TEMPLATE_STRINGS.phaseStart),
+        phaseEnd: z.string().default(DEFAULT_TEMPLATE_STRINGS.phaseEnd),
+        phaseError: z.string().default(DEFAULT_TEMPLATE_STRINGS.phaseError),
+    })
+        .default(() => ({ ...DEFAULT_TEMPLATE_STRINGS })),
     /** Interval in ms for periodic watcher health check. 0 = disabled. Default: 60000. */
     watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
     /** Logging configuration. */
@@ -819,7 +839,7 @@ const serviceConfigSchema = metaConfigSchema.extend({
 /**
  * Load and resolve jeeves-meta service config.
  *
- * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ * Supports environment-variable substitution (dollar-brace pattern).
  *
  * @module configLoader
  */
@@ -851,24 +871,10 @@ function substituteEnvVars(value) {
     }
     return value;
 }
-/**
- * Resolve \@file: references in a config value.
- *
- * @param value - String value that may start with "\@file:".
- * @param baseDir - Base directory for resolving relative paths.
- * @returns The resolved string (file contents or original value).
- */
-function resolveFileRef(value, baseDir) {
-    if (!value.startsWith('@file:'))
-        return value;
-    const filePath = join(baseDir, value.slice(6));
-    return readFileSync(filePath, 'utf8');
-}
 /**
  * Load service config from a JSON file.
  *
- * Resolves \@file: references for defaultArchitect and defaultCritic,
- * and substitutes environment-variable placeholders throughout.
+ * Substitutes environment-variable placeholders throughout.
  *
  * @param configPath - Path to config JSON file.
  * @returns Validated ServiceConfig.
@@ -876,13 +882,6 @@ function resolveFileRef(value, baseDir) {
 function loadServiceConfig(configPath) {
     const rawText = readFileSync(configPath, 'utf8');
     const raw = substituteEnvVars(JSON.parse(rawText));
-    const baseDir = dirname(configPath);
-    if (typeof raw['defaultArchitect'] === 'string') {
-        raw['defaultArchitect'] = resolveFileRef(raw['defaultArchitect'], baseDir);
-    }
-    if (typeof raw['defaultCritic'] === 'string') {
-        raw['defaultCritic'] = resolveFileRef(raw['defaultCritic'], baseDir);
-    }
     return serviceConfigSchema.parse(raw);
 }
 
@@ -1346,9 +1345,6 @@ function packageDirectorySync({cwd, ignoreTypeOnlyPackageJson} = {}) {
  * Prompts ship as .md files bundled into dist/prompts/ via rollup-plugin-copy.
  * Loaded at runtime relative to the compiled module location.
  *
- * Users can override via `defaultArchitect` / `defaultCritic` in the service
- * config. Most installations should use the built-in defaults.
- *
  * @module prompts
  */
 const packageRoot = packageDirectorySync({
@@ -1836,7 +1832,7 @@ function buildArchitectTask(ctx, meta, config) {
     const sections = [
         `# jeeves-meta · ARCHITECT · ${ctx.path}`,
         '',
-        config.defaultArchitect ?? DEFAULT_ARCHITECT_PROMPT,
+        DEFAULT_ARCHITECT_PROMPT,
         '',
         '## SCOPE',
         `Path: ${ctx.path}`,
@@ -1885,7 +1881,7 @@ function buildBuilderTask(ctx, meta, config) {
         includeSteer: false,
         feedbackHeading: '## FEEDBACK FROM CRITIC',
     });
-    sections.push('', '## OUTPUT FORMAT', '', 'Respond with ONLY a JSON object. No explanation, no markdown fences, no text before or after.', '', 'Required schema:', '{', '  "type": "object",', '  "required": ["_content"],', '  "properties": {', '    "_content": { "type": "string", "description": "Markdown narrative synthesis" },', '    "_state": { "description": "Opaque state object for progressive work across cycles" }', '  },', '  "additionalProperties": true', '}', '', 'Add any structured fields that capture important facts about this entity', '(e.g. status, risks, dependencies, metrics). Use descriptive key names without underscore prefix.', 'The _content field is the only required key — everything else is domain-driven.', '_state is optional: set it to carry state across synthesis cycles for progressive work.', '', 'DIAGRAMS: When diagrams would aid understanding, use PlantUML in fenced code blocks (```plantuml).', 'PlantUML is rendered natively by the serving infrastructure. NEVER use ASCII art diagrams.');
+    sections.push('', '## OUTPUT FORMAT', '', 'Respond with ONLY a JSON object. No explanation, no markdown fences, no text before or after.', '', 'Required schema:', '{', '  "type": "object",', '  "required": ["_content"],', '  "properties": {', '    "_content": { "type": "string", "description": "Markdown narrative synthesis" },', '    "_state": { "description": "Opaque state object for progressive work across cycles" }', '  },', '  "additionalProperties": true', '}', '', 'Add any structured fields that capture important facts about this entity', '(e.g. status, risks, dependencies, metrics). Use descriptive key names without underscore prefix.', 'The _content field is the only required key — everything else is domain-driven.', '_state is optional: set it to carry state across synthesis cycles for progressive work.', '', 'DIAGRAMS: When diagrams would aid understanding, use PlantUML in fenced code blocks (```plantuml).', 'PlantUML is rendered natively by the serving infrastructure. NEVER use ASCII art diagrams.', '', 'IMPORTANT: Do not call sessions_spawn or sessions_yield. Read all files directly using the tools', 'available in your session. Do not attempt to parallelize work by spawning sub-agents.');
     return compileTemplate(sections.join('\n'), buildTemplateContext(ctx, meta, config));
 }
 /**
@@ -1900,7 +1896,7 @@ function buildCriticTask(ctx, meta, config) {
     const sections = [
         `# jeeves-meta · CRITIC · ${ctx.path}`,
         '',
-        config.defaultCritic ?? DEFAULT_CRITIC_PROMPT,
+        DEFAULT_CRITIC_PROMPT,
         '',
         '## SYNTHESIS TO EVALUATE',
         meta._content ?? '(No content produced)',
@@ -2317,8 +2313,8 @@ async function computeInvalidation(meta, scopeFiles, config, node, crossRefMetas
     // through real builder cycles, architect runs with the current prompt and
     // the snapshot updates.  Coupling prompt changes to invalidation causes a
     // corpus-wide synthesis storm (see #163).
-    const architectChanged = isPromptStale(meta._architect, config.defaultArchitect ?? DEFAULT_ARCHITECT_PROMPT);
-    const criticChanged = isPromptStale(meta._critic, config.defaultCritic ?? DEFAULT_CRITIC_PROMPT);
+    const architectChanged = isPromptStale(meta._architect, DEFAULT_ARCHITECT_PROMPT);
+    const criticChanged = isPromptStale(meta._critic, DEFAULT_CRITIC_PROMPT);
     const effectiveSynthesisCount = meta._synthesisCount ?? 0;
     // _crossRefs declaration change
     const currentRefs = (meta._crossRefs ?? []).slice().sort().join(',');
@@ -2565,10 +2561,11 @@ function parseArchitectOutput(output) {
 /**
  * Parse builder output. The builder returns JSON with _content and optional fields.
  *
- * Attempts JSON parse first. If that fails, treats the entire output as _content.
+ * Attempts JSON extraction via multiple strategies. Returns null if all strategies fail
+ * (e.g. the output is plain text, self-talk, or a sub-agent delegation response).
  *
  * @param output - Raw subprocess output.
- * @returns Parsed builder output with content and structured fields.
+ * @returns Parsed builder output, or null if output is not valid builder JSON.
  */
 function parseBuilderOutput(output) {
     const trimmed = stripSentinel(output);
@@ -2597,8 +2594,8 @@ function parseBuilderOutput(output) {
         if (result)
             return result;
     }
-    // Fallback: treat entire output as content
-    return { content: trimmed, fields: {} };
+    // All JSON strategies failed — not valid builder output
+    return null;
 }
 /** Try to parse a string as JSON and extract builder output fields. */
 function tryParseJson(str) {
@@ -2726,7 +2723,7 @@ async function runArchitect(node, currentMeta, phaseState, config, executor, wat
         ps = architectSuccess(ps);
         const architectUpdates = {
             _builder: builderBrief,
-            _architect: config.defaultArchitect ?? DEFAULT_ARCHITECT_PROMPT,
+            _architect: DEFAULT_ARCHITECT_PROMPT,
             _synthesisCount: 0,
             _architectTokens: architectTokens,
             _generatedAt: new Date().toISOString(),
@@ -2798,6 +2795,12 @@ async function runBuilder(node, currentMeta, phaseState, config, executor, watch
             return { executed: true, phaseState: ps, updatedMeta };
         }
         const builderOutput = parseBuilderOutput(rawOutput);
+        if (!builderOutput) {
+            throw new Error('Builder output is not valid JSON — expected { _content|content: string, ... }. ' +
+                'Raw output (' +
+                rawOutput.length.toString() +
+                ' chars) did not match any JSON extraction strategy.');
+        }
         const builderTokens = result.tokens;
         // Builder success: builder → fresh, critic → pending
         ps = builderSuccess(ps);
@@ -2829,7 +2832,8 @@ async function runBuilder(node, currentMeta, phaseState, config, executor, watch
             try {
                 const raw = await readFile(err.outputPath, 'utf8');
                 const partial = parseBuilderOutput(raw);
-                if (partial.state !== undefined &&
+                if (partial !== null &&
+                    partial.state !== undefined &&
                     JSON.stringify(partial.state) !== JSON.stringify(currentMeta._state)) {
                     partialState = { _state: partial.state };
                 }
@@ -2872,7 +2876,7 @@ async function runCritic(node, currentMeta, phaseState, config, executor, watche
         const cycleComplete = isFullyFresh(ps);
         const updates = {
             _feedback: feedback,
-            _critic: config.defaultCritic ?? DEFAULT_CRITIC_PROMPT,
+            _critic: DEFAULT_CRITIC_PROMPT,
             _criticTokens: criticTokens,
             _error: undefined,
         };
@@ -3067,95 +3071,118 @@ async function executePhase(node, currentMeta, phaseState, phase, config, execut
 /**
  * Progress reporting via OpenClaw gateway `/tools/invoke` → `message` tool.
  *
+ * Progress events are rendered using Handlebars templates. Owner-path links
+ * are resolved via the jeeves-server resolve-path API, with graceful
+ * fallback to raw filesystem paths when the server is unreachable.
+ *
  * @module progress
  */
+/** Compile raw template strings into Handlebars delegates. */
+function compileTemplates(raw) {
+    const merged = {
+        phaseStart: raw?.phaseStart ?? DEFAULT_TEMPLATE_STRINGS.phaseStart,
+        phaseEnd: raw?.phaseEnd ?? DEFAULT_TEMPLATE_STRINGS.phaseEnd,
+        phaseError: raw?.phaseError ?? DEFAULT_TEMPLATE_STRINGS.phaseError,
+    };
+    return {
+        phaseStart: Handlebars.compile(merged.phaseStart),
+        phaseEnd: Handlebars.compile(merged.phaseEnd),
+        phaseError: Handlebars.compile(merged.phaseError),
+    };
+}
 function formatNumber(n) {
     return n.toLocaleString('en-US');
 }
-function formatTokens(tokens) {
-    return tokens !== undefined
-        ? formatNumber(tokens) + ' tokens'
-        : 'unknown tokens';
-}
-function formatSeconds(durationMs) {
-    const seconds = durationMs / 1000;
-    return Math.round(seconds).toString() + 's';
-}
-function titleCasePhase(phase) {
-    return phase.charAt(0).toUpperCase() + phase.slice(1);
-}
-/**
- * URL-encode each path segment individually so that spaces and special
- * characters are safe while preserving the `/` separators.
- */
-function encodePathSegments(p) {
-    return p
-        .split('/')
-        .map((seg) => encodeURIComponent(seg))
-        .join('/');
-}
-/** Build a link (or plain path) to the owner directory. */
-function buildDirectoryLink(path, serverBaseUrl) {
-    const normalized = normalizePath(path).replace(/^([A-Za-z]):/, '/$1');
-    const encoded = encodePathSegments(normalized);
-    if (!serverBaseUrl)
-        return normalized;
-    const base = serverBaseUrl.replace(/\/+$/, '');
-    return `${base}/path${encoded}`;
-}
-/** Build a link (or plain path) to the entity's meta.json output file. */
-function buildMetaJsonLink(path, serverBaseUrl) {
-    const normalized = normalizePath(path).replace(/^([A-Za-z]):/, '/$1');
-    const metaJsonPath = `${normalized}/.meta/meta.json`;
-    const encoded = encodePathSegments(metaJsonPath);
-    if (!serverBaseUrl)
-        return metaJsonPath;
-    const base = serverBaseUrl.replace(/\/+$/, '');
-    return `${base}/path${encoded}`;
-}
-function formatProgressEvent(event, serverBaseUrl) {
-    switch (event.type) {
-        case 'synthesis_start': {
-            const dirLink = buildDirectoryLink(event.path, serverBaseUrl);
-            return `🔬 Started meta synthesis: ${dirLink}`;
-        }
-        case 'phase_start': {
-            if (!event.phase) {
-                return '  ⚙️ Phase started';
-            }
-            return `  ⚙️ ${titleCasePhase(event.phase)} phase started`;
+/**
+ * Resolve a filesystem path to a browse URL via the jeeves-server
+ * resolve-path API. Returns the raw path as fallback on any failure.
+ *
+ * On HTTP 200, uses publicUrl if present, otherwise prefixes serverUrl
+ * to browseUrl. On any error or non-200 response, returns fsPath as-is.
+ */
+/** Timeout for resolve-path API calls (ms). */
+const RESOLVE_PATH_TIMEOUT_MS = 3000;
+async function resolveLink(fsPath, serverUrl) {
+    try {
+        const url = new URL('/api/resolve-path', serverUrl);
+        url.searchParams.set('fsPath', fsPath);
+        const res = await fetchWithTimeout(url.toString(), RESOLVE_PATH_TIMEOUT_MS);
+        if (!res.ok)
+            return fsPath;
+        const data = (await res.json());
+        if (data.publicUrl)
+            return data.publicUrl;
+        if (data.browseUrl) {
+            const base = serverUrl.replace(/\/+$/, '');
+            return base + data.browseUrl;
         }
+        return fsPath;
+    }
+    catch {
+        return fsPath;
+    }
+}
+/** Resolve browse links for both the owner directory and its meta.json. */
+async function resolveLinks(ownerPath, serverUrl) {
+    const dirLink = await resolveLink(ownerPath, serverUrl);
+    // Derive metaLink by appending /.meta/meta.json to the resolved dir link
+    const metaLink = dirLink.replace(/\/+$/, '') + '/.meta/meta.json';
+    return { dirLink, metaLink };
+}
+/**
+ * Render the appropriate template for a progress event.
+ *
+ * @param event - The progress event to render.
+ * @param templates - Compiled Handlebars templates.
+ * @param serverUrl - jeeves-server URL for resolve-path API.
+ * @returns Rendered message string.
+ */
+async function renderProgressEvent(event, templates, serverUrl) {
+    const ownerPath = event.path;
+    const metaPath = ownerPath.replace(/\/+$/, '') + '/.meta/meta.json';
+    const phase = (event.phase ?? 'unknown').toUpperCase();
+    const { dirLink, metaLink } = await resolveLinks(ownerPath, serverUrl);
+    const base = {
+        dirPath: ownerPath,
+        metaPath,
+        dirLink,
+        metaLink,
+        phase,
+    };
+    switch (event.type) {
+        case 'phase_start':
+            return templates.phaseStart(base);
         case 'phase_complete': {
-            const phase = event.phase ? titleCasePhase(event.phase) : 'Phase';
-            const tokenStr = formatTokens(event.tokens);
-            const duration = event.durationMs !== undefined ? formatSeconds(event.durationMs) : '0s';
-            return `  ✅ ${phase} complete (${tokenStr} / ${duration})`;
-        }
-        case 'synthesis_complete': {
-            const metaLink = buildMetaJsonLink(event.path, serverBaseUrl);
-            const tokenStr = formatTokens(event.tokens);
-            const duration = event.durationMs !== undefined
-                ? formatSeconds(event.durationMs)
-                : '0.0s';
-            return `✅ Completed: ${metaLink} (${tokenStr} / ${duration})`;
+            const seconds = event.durationMs !== undefined
+                ? String(Math.round(event.durationMs / 1000))
+                : '0';
+            const tokens = event.tokens !== undefined ? formatNumber(event.tokens) : 'unknown';
+            return templates.phaseEnd({ ...base, seconds, tokens });
         }
         case 'error': {
-            const dirLink = buildDirectoryLink(event.path, serverBaseUrl);
-            const phase = event.phase ? `${titleCasePhase(event.phase)} ` : '';
-            const error = event.error ?? 'Unknown error';
-            return `❌ Synthesis failed at ${phase}phase: ${dirLink}\n   Error: ${error}`;
+            const seconds = event.durationMs !== undefined
+                ? String(Math.round(event.durationMs / 1000))
+                : '0';
+            const errorMsg = event.error ?? 'Unknown error';
+            return templates.phaseError({ ...base, seconds, error: errorMsg });
         }
-        default: {
+        default:
             return 'Unknown progress event';
-        }
     }
 }
 class ProgressReporter {
     config;
     logger;
+    templates;
+    /** Snapshot of template source strings used to compile `this.templates`. */
+    lastTemplateSource;
+    serverUrl;
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
+        this.templates = compileTemplates(config.templates);
+        this.lastTemplateSource = JSON.stringify(config.templates);
+        this.serverUrl = config.serverUrl ?? 'http://127.0.0.1:1934';
     }
     async report(event) {
         // Multi-channel mode: reportTarget is the destination, reportChannel is the platform.
@@ -3163,7 +3190,27 @@ class ProgressReporter {
         const target = this.config.reportTarget ?? this.config.reportChannel;
         if (!target)
             return;
-        const message = formatProgressEvent(event, this.config.serverBaseUrl);
+        // Detect template hot-reload: config.templates may be mutated by
+        // applyHotReloadedConfig; recompile when the source strings change.
+        const currentSource = JSON.stringify(this.config.templates);
+        if (currentSource !== this.lastTemplateSource) {
+            try {
+                this.templates = compileTemplates(this.config.templates);
+                this.lastTemplateSource = currentSource;
+                this.logger.info('Progress templates recompiled (hot-reload)');
+            }
+            catch (err) {
+                this.logger.warn({ err }, 'Failed to compile hot-reloaded templates; keeping previous templates');
+            }
+        }
+        let message;
+        try {
+            message = await renderProgressEvent(event, this.templates, this.serverUrl);
+        }
+        catch (err) {
+            this.logger.warn({ err }, 'Progress event rendering failed');
+            return;
+        }
         const url = new URL('/tools/invoke', this.config.gatewayUrl);
         const args = {
             action: 'send',
@@ -4741,6 +4788,7 @@ function registerStatusRoute(app, deps) {
                 critic: emptyPhaseCounts(),
             };
             let nextPhase = null;
+            let metaCounts = null;
             try {
                 const metaResult = await cache.get(config, watcher);
                 // Count raw phase states (before retry) for display
@@ -4762,6 +4810,17 @@ function registerStatusRoute(app, deps) {
                         staleness: winner.effectiveStaleness,
                     };
                 }
+                // Meta counts summary
+                const summary = computeSummary(metaResult.entries, config.depthWeight);
+                metaCounts = {
+                    total: summary.total,
+                    enabled: summary.total - summary.disabled,
+                    disabled: summary.disabled,
+                    neverSynthesized: summary.neverSynthesized,
+                    stale: summary.stale,
+                    errors: summary.errors,
+                    locked: summary.locked,
+                };
             }
             catch {
                 // Watcher unreachable — phase summary unavailable
@@ -4790,6 +4849,7 @@ function registerStatusRoute(app, deps) {
                 },
                 phaseStateSummary,
                 nextPhase,
+                metaCounts,
             };
         },
     });
@@ -5099,11 +5159,10 @@ class HttpWatcherClient {
     async post(endpoint, body) {
         const url = this.baseUrl + endpoint;
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-            const res = await fetch(url, {
+            const res = await fetchWithTimeout(url, this.timeoutMs, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.timeout(this.timeoutMs),
             });
             if (res.ok) {
                 return res.json();
@@ -5145,25 +5204,6 @@ class HttpWatcherClient {
  *
  * @module bootstrap
  */
-/**
- * Compute per-cycle token total from a completed meta.
- *
- * Exported for testing.
- *
- * Uses `_synthesisCount` as a discriminator: after increment by `runCritic`,
- * a value of 1 means architect ran this cycle (was 0 pre-increment),
- * so all three phase token fields are summed. A value \> 1 means architect
- * was skipped (cached brief reused), so only builder + critic are summed.
- */
-function computeCycleTokens(meta) {
-    const builderTokens = meta._builderTokens ?? 0;
-    const criticTokens = meta._criticTokens ?? 0;
-    const architectRan = (meta._synthesisCount ?? 1) === 1;
-    const architectTokens = architectRan
-        ? (meta._architectTokens ?? 0)
-        : 0;
-    return architectTokens + builderTokens + criticTokens;
-}
 /**
  * Bootstrap the service: create logger, build server, start listening,
  * wire scheduler, queue processing, rule registration, config hot-reload,
@@ -5240,16 +5280,7 @@ async function startService(config, configPath) {
             // Track whether synthesis_start has been emitted (deferred until
             // a phase actually begins, avoiding orphan "Started" messages
             // when the meta is skipped/locked/fresh). See #165.
-            let synthesisStartEmitted = false;
             const result = await orchestratePhase(config, executor, watcher, path, async (evt) => {
-                // Emit synthesis_start on first phase_start (deferred guard)
-                if (evt.type === 'phase_start' && !synthesisStartEmitted) {
-                    synthesisStartEmitted = true;
-                    await progress.report({
-                        type: 'synthesis_start',
-                        path: ownerPath,
-                    });
-                }
                 // Wire current-phase tracking for GET /queue and POST /synthesize/abort
                 if (evt.type === 'phase_start' && evt.phase) {
                     queue.setCurrentPhase(ownerPath, evt.phase);
@@ -5291,19 +5322,8 @@ async function startService(config, configPath) {
                 // Task #9: Reset backoff on ANY successful phase execution
                 scheduler.resetBackoff();
             }
-            // Emit synthesis_complete only on full-cycle completion
-            if (result.cycleComplete) {
-                const updatedMeta = result.phaseResult?.updatedMeta;
-                const tokens = updatedMeta
-                    ? computeCycleTokens(updatedMeta)
-                    : undefined;
-                await progress.report({
-                    type: 'synthesis_complete',
-                    path: ownerPath,
-                    durationMs,
-                    tokens,
-                });
-            }
+            // Note: synthesis_complete is no longer emitted; the phaseEnd template
+            // for the final critic phase serves as the completion signal (#129).
         }
         catch (err) {
             stats.totalErrors++;

package/dist/configHotReload.d.ts

@@ -15,7 +15,7 @@ import type { ServiceConfig } from './schema/config.js';
  * Shared between the descriptor's `onConfigApply` and the file-watcher
  * hot-reload in `bootstrap.ts`.
  */
-export declare const RESTART_REQUIRED_FIELDS: readonly ["port", "watcherUrl", "gatewayUrl", "gatewayApiKey", "defaultArchitect", "defaultCritic"];
+export declare const RESTART_REQUIRED_FIELDS: readonly ["port", "watcherUrl", "gatewayUrl", "gatewayApiKey"];
 interface ConfigHotReloadRuntime {
     config: ServiceConfig;
     logger: Logger;

package/dist/configLoader.d.ts

@@ -1,7 +1,7 @@
 /**
  * Load and resolve jeeves-meta service config.
  *
- * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ * Supports environment-variable substitution (dollar-brace pattern).
  *
  * @module configLoader
  */
@@ -28,8 +28,7 @@ export declare function resolveConfigPath(args: string[]): string;
 /**
  * Load service config from a JSON file.
  *
- * Resolves \@file: references for defaultArchitect and defaultCritic,
- * and substitutes environment-variable placeholders throughout.
+ * Substitutes environment-variable placeholders throughout.
  *
  * @param configPath - Path to config JSON file.
  * @returns Validated ServiceConfig.

package/dist/index.d.ts

@@ -19,7 +19,7 @@ export type { InferenceRuleSpec, MetaContext, MetaExecutor, MetaSpawnOptions, Me
 export type { LoggerConfig } from './logger/index.js';
 export { createLogger, type MinimalLogger } from './logger/index.js';
 export { buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, type BuilderOutput, orchestratePhase, type OrchestratePhaseResult, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, type PhaseProgressCallback, type PhaseResult, runArchitect, runBuilder, runCritic, } from './orchestrator/index.js';
-export { formatProgressEvent, type ProgressEvent, type ProgressPhase, ProgressReporter, type ProgressReporterConfig, } from './progress/index.js';
+export { type ProgressEvent, type ProgressPhase, ProgressReporter, type ProgressReporterConfig, renderProgressEvent, type TemplateStrings, } from './progress/index.js';
 export { actualStaleness, computeEffectiveStaleness, hasSteerChanged, isArchitectTriggered, isStale, MAX_STALENESS_SECONDS, type StalenessCandidate, } from './scheduling/index.js';
 export { type MetaConfig, metaConfigSchema, type MetaError, metaErrorSchema, type MetaJson, metaJsonSchema, type ServiceConfig, serviceConfigSchema, } from './schema/index.js';
 export { Scheduler } from './scheduler/index.js';