@intutic/sync-daemon 1.9.0 → 1.10.1

package/dist/syncLoop.js

@@ -23,33 +23,165 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import { newIso } from '@intutic/id';
-import { writeConfigFiles, HARNESS_FILES, applyConfigEdits } from './configWriter.js';
+import { deriveEnforcementInputs } from '@intutic/shared-types';
+import { writeConfigFiles, HARNESS_FILES, applyConfigEdits, loadLocalSopEntries } from './configWriter.js';
+import { injectMcpServer } from './harness/mcpAutoWrite.js';
+import { discoverWorktrees } from './lib/gitWorktrees.js';
 import { computeFileHashes } from './hashReporter.js';
 import { loadIntegrity, saveIntegrity } from './integrityStore.js';
-import { drainHookEvents } from './harness/claudeCodeHooks.js';
+import { drainHookEvents, drainReviewRequests, REVIEW_REQUESTS_LOG, parseSopConstraints, } from './harness/claudeCodeHooks.js';
 import { writeRuntimeEnv } from './lib/runtimeEnv.js';
+import { refreshPolicySnapshot } from './lib/policySnapshot.js';
+import { refreshApprovedBypasses } from './lib/approvedBypasses.js';
+import { refreshEgressPolicy } from './lib/egressPolicy.js';
+import { refreshDecisionsDigest } from './lib/decisionsDigest.js';
 import { runComplianceProbes } from './lib/complianceProbes.js';
 import { startWatcher } from './watcher/driftWatcher.js';
 import { shouldCaptureThisIteration, captureAndUpload } from './configReader.js';
 import { watch } from 'chokidar';
-import Redis from 'ioredis';
+// Named import, not default: this package is ESM ("type": "module") and under
+// Node16 resolution the default import of ioredis's CJS typings resolves to the
+// module namespace, which is neither constructable nor usable as a type. The
+// named export is the class itself. (The old `new (Redis as any)(...)` cast
+// silenced exactly this, at the cost of also erasing the instance type.)
+import { Redis } from 'ioredis';
 import { TrajectoryMonitor } from './trajectoryMonitor.js';
+import { collectAgentReport, reportAgent, fetchLocalProxyInstanceId } from './agentReporter.js';
+import { startHarnessSession, endAllOpenSessions } from './sessionReporter.js';
+/** Narrow an unknown thrown value to a printable message. */
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Structural guard for trace events arriving over the `trace:live:*` Valkey
+ * channel. The payload is JSON off the wire, so it is genuinely unknown here;
+ * `handleTraceEvent` indexes `sessionId`/`workspaceId` immediately and a
+ * malformed publish would otherwise fault inside the buffer bookkeeping.
+ */
+function isTraceEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const e = value;
+    return typeof e['sessionId'] === 'string' && typeof e['workspaceId'] === 'string';
+}
+/**
+ * Turns a non-clean `scanSkillContent` result — already computed as part of
+ * `collectAgentReport`'s `facets.skills` — into a `skill_flagged` hook event
+ * (TD-358).
+ *
+ * Deliberately reuses the report the daemon already built for this cycle
+ * rather than re-scanning: `agentReporter.ts`'s `collectSkills` runs
+ * `scanSkillContent` on every `.agents/skills/**\/SKILL.md` as part of
+ * building `facets.skills` already, so this only turns a result the daemon
+ * already has into a visible signal — it does not add a second scan pass.
+ *
+ * Appends directly to `.intutic/events/hook-events.jsonl`, the SAME file
+ * every emitted PreToolUse gate's `log_event`/`logEvent` writes to and the
+ * SAME mechanism `onDriftDetected` below already uses for `config_tamper` —
+ * not a new event pipeline. `drainHookEvents` (`claudeCodeHooks.ts`) picks
+ * this line up on its next pass exactly like a gate-written one, because it
+ * only ever reads the file; it does not care who appended a given line.
+ *
+ * Report-only, per `scanSkillContent`'s own doc comment on the unmeasured
+ * false-positive rate against real, benign skill markdown: this NEVER
+ * blocks, mutates, or removes a skill. `hookEvents.ts`'s
+ * `HookEventSchema.event` enum (control plane) counts `skill_flagged`
+ * exactly like `tool_flagged` — advisory telemetry, not an incident.
+ *
+ * A failure to append is caught and warned, never thrown: a governance
+ * telemetry write must not be able to abort the sync cycle it rides in on.
+ */
+export function emitSkillFlaggedEvents(opts) {
+    const eventsLog = path.join(opts.workspaceRoot, '.intutic', 'events', 'hook-events.jsonl');
+    for (const skill of opts.skills) {
+        if (!skill.scanned || skill.clean)
+            continue;
+        const key = `${skill.source}:${skill.name}`;
+        if (opts.alreadyEmitted.has(key))
+            continue;
+        opts.alreadyEmitted.add(key);
+        try {
+            const ts = newIso();
+            const entry = JSON.stringify({
+                event: 'skill_flagged',
+                toolName: `skill:${skill.name}`,
+                reason: `scanSkillContent found ${skill.findingsCount} finding(s) in ` +
+                    `${skill.source}/${skill.name}/SKILL.md — advisory only, see skillScan.ts`,
+                workspaceId: opts.workspaceId,
+                harnessType: opts.harnessType,
+                timestamp: ts,
+                incidentId: crypto
+                    .createHash('sha1')
+                    .update(ts + skill.name + opts.workspaceId)
+                    .digest('hex')
+                    .slice(0, 16),
+                filePath: `${skill.source}/${skill.name}/SKILL.md`,
+            }) + '\n';
+            fs.appendFileSync(eventsLog, entry, { flag: 'a' });
+        }
+        catch (err) {
+            console.warn('[sync-daemon] failed to write skill_flagged event (non-fatal):', err);
+        }
+    }
+}
 // ─── Default constants ───────────────────────────────────────────────
 const DEFAULT_POLL_INTERVAL_MS = 30_000;
-// ─── Core sync loop ──────────────────────────────────────────────────
 /**
- * Start the sync loop. This function runs indefinitely until the
- * AbortSignal is triggered or the process exits.
+ * Best-effort reachability probe for the control plane, modelled on
+ * `agentReporter.fetchEgressStatus()`'s bounded-fetch-and-swallow shape.
  *
- * @param options - Sync loop configuration.
+ * The trajectory monitor used to start on `VALKEY_URL || apiKey` alone —
+ * never checking `controlPlaneUrl` at all, so an unset URL produced
+ * `undefined/api/v1/...` on every submit attempt. This is the missing check:
+ * a monitor that will publish its summaries to a URL that does not resolve
+ * (or does not answer) should not start believing it has somewhere to send
+ * them.
+ */
+async function controlPlaneIsReachable(controlPlaneUrl) {
+    if (!controlPlaneUrl)
+        return false;
+    try {
+        const res = await fetch(`${controlPlaneUrl}/healthz`, { signal: AbortSignal.timeout(2000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The `review_before:` tokens the snapshot compiles into hold rules: from the
+ * synced SOPs' front matter and JSON blocks, the workspace settings, and the
+ * local `.intutic/sops`. The same parse the Claude Code writer runs for its
+ * pattern blacklist, so the two cannot disagree about what is held.
  */
+export async function localHoldTokensFor(workspaceRoot, sops, settings, harnesses = []) {
+    const local = await loadLocalSopEntries(workspaceRoot, harnesses);
+    return parseSopConstraints([...sops, ...local], settings).reviewBefore;
+}
+/**
+ * Refresh the three gate-side caches every hook reads: the policy snapshot
+ * (`~/.intutic/hooks/policy-snapshot.rules`), the approved review-hold
+ * bypasses and the central egress policy. Called on EVERY sync cycle by both
+ * loops — this one and `intutic connect`'s — never only when the config
+ * version moved: policy changes without the version changing, and before
+ * this helper existed `connect` refreshed once at startup and never again, so
+ * a guardrail promoted mid-session reached a connected machine only on
+ * restart (TD-488). None of the three throw; the return says which of them
+ * landed.
+ */
+export async function refreshGateCaches(opts) {
+    const snapshot = (await refreshPolicySnapshot(opts)) !== null;
+    const bypasses = (await refreshApprovedBypasses(opts)) !== null;
+    const egress = (await refreshEgressPolicy(opts)) !== null;
+    return { snapshot, bypasses, egress };
+}
 export async function startSyncLoop(options) {
-    const { controlPlaneUrl, apiKey, workspaceId, workspaceRoot, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, onSync, signal, adapterId, } = options;
+    const { controlPlaneUrl, apiKey, workspaceId, workspaceRoot, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, onSync, signal, } = options;
     // Step -1: Start the Trajectory Monitor & Valkey Subscriber
     let trajectoryMonitor = null;
     let trajectorySubscriber = null;
-    if (process.env.VALKEY_URL || apiKey) {
-        const valkeyUrl = process.env.VALKEY_URL ?? 'redis://127.0.0.1:6379';
+    const valkeyUrl = process.env.VALKEY_URL ?? 'redis://127.0.0.1:6379';
+    if ((process.env.VALKEY_URL || apiKey) && (await controlPlaneIsReachable(controlPlaneUrl))) {
         trajectoryMonitor = new TrajectoryMonitor({
             valkeyUrl,
             controlPlaneUrl,
@@ -61,9 +193,13 @@ export async function startSyncLoop(options) {
             await trajectoryMonitor.start();
             trajectorySubscriber = new Redis(valkeyUrl);
             await trajectorySubscriber.psubscribe('trace:live:*');
-            trajectorySubscriber.on('pmessage', (pattern, channel, message) => {
+            trajectorySubscriber.on('pmessage', (_pattern, _channel, message) => {
                 try {
                     const event = JSON.parse(message);
+                    if (!isTraceEvent(event)) {
+                        console.warn('[sync-daemon] Discarding malformed trajectory trace event');
+                        return;
+                    }
                     trajectoryMonitor?.handleTraceEvent(event);
                 }
                 catch (err) {
@@ -82,14 +218,32 @@ export async function startSyncLoop(options) {
     let latestSops = [];
     let latestProxyUrl = '';
     let latestHarnesses = [];
+    let latestGovernanceInputs = {};
     // Step 0: Write runtime env file (hook scripts source this for credentials)
     // Runs once at startup and then again on every iteration.
     try {
-        await writeRuntimeEnv({ controlPlaneUrl, apiKey, workspaceId });
+        // The Valkey URL rides along only when this loop is itself using one
+        // (the trajectory monitor connected): the MCP proxies share their session
+        // window through it (Wave 5.3, TD-437).
+        await writeRuntimeEnv({ controlPlaneUrl, apiKey, workspaceId, valkeyUrl: trajectoryMonitor ? valkeyUrl : undefined });
     }
     catch (err) {
         console.warn('[sync-daemon] Could not write runtime env file (non-fatal):', err);
     }
+    // Step 0b–0d: Refresh the three gate-side caches every hook reads —
+    // policy snapshot, approved review_before bypasses, central egress policy.
+    //
+    // Deliberately here beside writeRuntimeEnv, and deliberately NOT inside
+    // writeConfigFiles: that path is gated on the config version, so a snapshot
+    // written there would go stale by construction on every cycle where the
+    // version did not move. Policy changes without the config version changing,
+    // and a bypass an operator just approved has to reach the gate before the
+    // developer's very next retry. One helper, shared with `intutic connect`'s
+    // own loop, so the two cannot drift apart again (TD-488).
+    await refreshGateCaches({
+        controlPlaneUrl, apiKey, workspaceId,
+        localHoldTokens: await localHoldTokensFor(workspaceRoot, [], undefined),
+    });
     // Try to sync offline traces back to PostgreSQL
     try {
         await syncOfflineTraces(controlPlaneUrl, apiKey);
@@ -101,6 +255,10 @@ export async function startSyncLoop(options) {
     // Drains immediately when the hook-events.jsonl file changes (written by hook scripts).
     // Falls back to a 60s safety-net interval for NFS/Docker mounts where inotify may not fire.
     const hookEventsLog = `${workspaceRoot}/.intutic/events/hook-events.jsonl`;
+    // The review-hold log, watched alongside it. Two named files rather than the
+    // directory: a directory watch would also fire on `.rejected.jsonl`, which the
+    // drain itself writes, and a drain that retriggers itself is a loop.
+    const reviewHoldsLog = `${workspaceRoot}/${REVIEW_REQUESTS_LOG}`;
     let fsWatcher = null;
     let drainSafetyTimer = null;
     const runDrain = async () => {
@@ -113,9 +271,20 @@ export async function startSyncLoop(options) {
         catch (err) {
             console.warn('[sync-daemon] Hook event drain error (non-fatal):', err);
         }
+        // Separate try: a failure draining events must not skip the holds. They go
+        // to different endpoints and one being down says nothing about the other.
+        try {
+            const held = await drainReviewRequests(workspaceRoot, controlPlaneUrl, apiKey);
+            if (held > 0) {
+                console.log(`[sync-daemon] Drained ${held} review hold(s) to control plane`);
+            }
+        }
+        catch (err) {
+            console.warn('[sync-daemon] Review hold drain error (non-fatal):', err);
+        }
     };
     try {
-        fsWatcher = watch(hookEventsLog, { ignoreInitial: true, persistent: false });
+        fsWatcher = watch([hookEventsLog, reviewHoldsLog], { ignoreInitial: true, persistent: false });
         fsWatcher.on('change', runDrain);
         fsWatcher.on('add', runDrain);
     }
@@ -173,7 +342,6 @@ export async function startSyncLoop(options) {
                 workspaceId,
                 workspaceRoot,
                 onSync,
-                adapterId,
             });
             // Update cached state for drift handler
             if (result) {
@@ -181,6 +349,7 @@ export async function startSyncLoop(options) {
                 latestSops = result.sops ?? [];
                 latestProxyUrl = result.proxyUrl ?? '';
                 latestHarnesses = result.harnesses ?? [];
+                latestGovernanceInputs = result.harnessGovernanceInputs ?? {};
                 await writeRuntimeEnv({
                     controlPlaneUrl,
                     apiKey,
@@ -188,7 +357,32 @@ export async function startSyncLoop(options) {
                     mcpProxyFailBehavior: result.settings?.mcpProxyFailBehavior,
                     mcpProxyMode: result.settings?.mcpProxyMode,
                     bypassEnforcementTier: result.settings?.bypassEnforcementTier,
+                    valkeyUrl: trajectoryMonitor ? valkeyUrl : undefined,
+                });
+                // Same reasoning as Step 0b–0d: policy rides the sync cycle, not the
+                // config version.
+                await refreshGateCaches({
+                    controlPlaneUrl, apiKey, workspaceId,
+                    localHoldTokens: await localHoldTokensFor(workspaceRoot, latestSops, latestSettings, latestHarnesses),
                 });
+                // Governed decisions log — opt-in only (WorkspaceSettings.decisionsLogEnabled,
+                // default off: a growing context file is token spend the product must not
+                // silently impose on every workspace). No Step-0-equivalent unconditional
+                // call before the loop, unlike egress/policy/bypasses above: this gate can
+                // only be evaluated once `result.settings` is known, which is not yet true
+                // before the first iteration completes. When disabled, this is simply not
+                // called — existing files (if any, from before the workspace disabled the
+                // feature) are left as last written rather than force-deleted or overwritten
+                // with a stale/wrong "disabled" digest.
+                if (result.settings?.decisionsLogEnabled) {
+                    await refreshDecisionsDigest({
+                        controlPlaneUrl,
+                        apiKey,
+                        workspaceId,
+                        workspaceRoot,
+                        harnesses: latestHarnesses,
+                    });
+                }
             }
             // Start the drift watcher on first successful sync (once harnesses are known)
             if (!driftWatcher && latestHarnesses.length > 0) {
@@ -216,7 +410,7 @@ export async function startSyncLoop(options) {
             // 4b. Capture harness configs back to control plane (every Nth iteration)
             if (shouldCaptureThisIteration(iterationCount)) {
                 try {
-                    await captureAndUpload(controlPlaneUrl, apiKey, workspaceId, workspaceRoot, latestHarnesses);
+                    await captureAndUpload(controlPlaneUrl, apiKey, workspaceId, workspaceRoot, latestHarnesses, latestGovernanceInputs);
                 }
                 catch (err) {
                     console.warn('[sync-daemon] Config capture failed (non-fatal):', err);
@@ -234,6 +428,9 @@ export async function startSyncLoop(options) {
     driftWatcher?.stop();
     if (drainSafetyTimer)
         clearInterval(drainSafetyTimer);
+    // Mark this run's harness sessions ended so the dashboard's live list
+    // reflects reality.
+    await endAllOpenSessions(controlPlaneUrl, apiKey);
 }
 /**
  * Execute a single sync iteration:
@@ -243,9 +440,16 @@ export async function startSyncLoop(options) {
  * 4. Report status back to control plane
  * 5. Update local integrity store
  * 6. Call onSync callback
+ *
+ * Exported (in addition to being used internally by `startSyncLoop`'s
+ * polling loop) as a test seam — it is the unit that exercises exactly one
+ * cycle's worth of work, including the injectMcpServer call (step 3c),
+ * without the surrounding while-loop's extra one-time/Nth-iteration network
+ * calls (policy snapshot, approved bypasses, egress policy, compliance
+ * probes, drift watcher, decisions digest, config capture).
  */
-async function runSyncIteration(ctx) {
-    const { controlPlaneUrl, apiKey, workspaceId, workspaceRoot, onSync, adapterId } = ctx;
+export async function runSyncIteration(ctx) {
+    const { controlPlaneUrl, apiKey, workspaceId, workspaceRoot, onSync } = ctx;
     // 1. Fetch config from control plane
     const config = await fetchConfig(controlPlaneUrl, apiKey, workspaceId);
     // 2. Load local integrity store
@@ -276,8 +480,21 @@ async function runSyncIteration(ctx) {
             : config.appliedEdits.filter(edit => !localAppliedIds.includes(edit.suggestionId));
         if (toApply.length > 0) {
             try {
-                await applyConfigEdits(workspaceRoot, toApply, config.settings.bypassEnforcementTier);
-                const newlyAppliedIds = Array.from(new Set([...localAppliedIds, ...toApply.map(e => e.suggestionId)]));
+                const results = await applyConfigEdits(workspaceRoot, toApply, config.settings.bypassEnforcementTier);
+                // Ack every result back to control-plane (TD-349). Best-effort per
+                // suggestion — one failed ack must not block the others or abort
+                // the sync cycle; see reportApplyResult's own non-fatal handling.
+                for (const result of results) {
+                    await reportApplyResult(controlPlaneUrl, apiKey, result.suggestionId, result);
+                }
+                // Only remember ids that fully landed (every operation for that
+                // suggestion applied). Recording every ATTEMPTED id regardless of
+                // outcome (the old behavior) meant a fuzzy-match miss was silently
+                // never retried — the id was in applied-suggestions.json forever,
+                // and forceApply is the only other thing that re-attempts an id
+                // already in this file. A failed edit must remain retryable.
+                const landedIds = results.filter((r) => r.ok).map((r) => r.suggestionId);
+                const newlyAppliedIds = Array.from(new Set([...localAppliedIds, ...landedIds]));
                 try {
                     fs.mkdirSync(path.dirname(appliedSuggestionsPath), { recursive: true });
                     fs.writeFileSync(appliedSuggestionsPath, JSON.stringify(newlyAppliedIds, null, 2), 'utf-8');
@@ -291,6 +508,56 @@ async function runSyncIteration(ctx) {
             }
         }
     }
+    // 3c. Proxy-wrap MCP servers across all supported harness configs. This is
+    // a continuous invariant, not a one-shot done only at `connect` time: a
+    // server a user adds to a harness config after their first `connect` would
+    // otherwise never get wrapped and stay invisible to governance. Safe to run
+    // every cycle because mcpAutoWrite's writeJsonFile is write-if-changed — an
+    // already-wrapped, unchanged config writes zero bytes. Non-fatal, matching
+    // step 3b above: a failure here must not abort the sync cycle.
+    try {
+        await injectMcpServer(workspaceRoot, workspaceId);
+    }
+    catch (err) {
+        console.warn('[sync-daemon] injectMcpServer failed (non-fatal):', err);
+    }
+    // 3d. Worktree propagation (O1). `workspaceRoot` above only ever covers the
+    // ONE checkout this daemon was pointed at — a `git worktree add`-created
+    // sibling checkout has its own independent working tree, and every
+    // project-tier governance file this product writes is untracked, so none
+    // of it exists in a worktree by default (see gitWorktrees.ts's module doc
+    // for the full mechanics and why Xirp is what surfaced this). Discovering
+    // worktrees fresh every cycle — never caching the list across
+    // iterations — is what makes worktree REMOVAL fall out for free: a
+    // worktree `git worktree remove`d since the last cycle simply stops being
+    // returned here, with no stale-entry cleanup logic required.
+    //
+    // Config-content writes reuse the SAME `config.configVersion > localVersion`
+    // gate step 3 already used — every worktree of one repo shares the one
+    // control-plane config, so re-deriving per-worktree versioning would just
+    // reproduce a decision already made above. `injectMcpServer` runs
+    // unconditionally per worktree, same as it does for the main root: it is
+    // write-if-changed internally (mcpAutoWrite's writeJsonFile), so an
+    // unchanged worktree costs a few file reads and no writes.
+    try {
+        const worktrees = await discoverWorktrees(workspaceRoot);
+        for (const worktreeRoot of worktrees) {
+            if (worktreeRoot === workspaceRoot)
+                continue; // already covered above
+            try {
+                if (config.configVersion > localVersion) {
+                    await writeConfigFiles(worktreeRoot, config.sops, config.proxyUrl, extractHarnesses(config));
+                }
+                await injectMcpServer(worktreeRoot, workspaceId);
+            }
+            catch (err) {
+                console.warn(`[sync-daemon] worktree propagation failed for ${worktreeRoot} (non-fatal):`, err);
+            }
+        }
+    }
+    catch (err) {
+        console.warn('[sync-daemon] discoverWorktrees failed (non-fatal):', err);
+    }
     // 4. Compute file hashes for drift detection
     const harnesses = extractHarnesses(config);
     const canonicalHashes = buildCanonicalHashMap(config);
@@ -306,6 +573,71 @@ async function runSyncIteration(ctx) {
             await reportStatus(controlPlaneUrl, apiKey, workspaceId, harness, harnessHashes);
         }
     }
+    // 5b. Register each harness as a durable agent with its facets, so the
+    // dashboard agent graph + posture ring stay live. Best-effort: a failed
+    // report never blocks the sync loop.
+    //
+    // Skills scanned this cycle whose finding has already been emitted, keyed
+    // `source:name`. `collectAgentReport` recomputes the same workspace-wide
+    // skill scan once per harness in this loop — a skill is not harness-
+    // specific — so without this a workspace with two active harnesses would
+    // double-emit every flagged skill every cycle.
+    const skillFlaggedThisCycle = new Set();
+    // Per-harness governance-coverage enforcement signals for this cycle,
+    // derived from the same facets `collectAgentReport` just computed — see
+    // `SyncResult.harnessGovernanceInputs`'s doc comment. Uses the shared
+    // `deriveEnforcementInputs` (`@intutic/shared-types`, TD-443) so this
+    // mapping cannot drift from `harnessGradeSweep.ts`'s control-plane-side
+    // sweep the way the two hand-kept copies previously did — safe to depend
+    // on since `@intutic/shared-types` is a leaf package, not
+    // `services/control-plane` itself, so this publicly-mirrored module still
+    // never imports from the enterprise-only service.
+    const harnessGovernanceInputs = {};
+    // The local proxy's instance id, read once per iteration (not per harness):
+    // step 5c registers each harness's git/task context onto that process's own
+    // session row (TD-231, Wave 5.6). `null` — no local proxy, or a shared
+    // gateway — keeps the `ses_` fallback. Skipped when there is no harness to
+    // report, so a workspace with no SOP targets never probes the proxy.
+    const proxyInstanceId = harnesses.length > 0 ? await fetchLocalProxyInstanceId() : null;
+    for (const harness of harnesses) {
+        const filename = HARNESS_FILES[harness];
+        const configSynced = filename
+            ? !fileHashes.some((f) => f.filePath === filename && f.drifted)
+            : false;
+        const report = await collectAgentReport({
+            workspaceRoot,
+            harnessType: harness,
+            configSynced,
+            dlpEnabled: true, // the daemon-managed proxy ships DLP on by default
+            policyEnforced: Boolean(controlPlaneUrl),
+            allowLocalVaults: config.settings?.allowLocalMemoryVaults,
+        });
+        await reportAgent(controlPlaneUrl, apiKey, workspaceId, report);
+        harnessGovernanceInputs[harness] = deriveEnforcementInputs(report.facets);
+        // 5b-i. Skill-content scan findings, surfaced as `skill_flagged` events
+        // (TD-358). See `emitSkillFlaggedEvents`'s own doc comment for why this
+        // rides the existing hook-events drain rather than a new pipeline.
+        emitSkillFlaggedEvents({
+            workspaceRoot,
+            workspaceId,
+            harnessType: harness,
+            skills: report.facets.skills,
+            alreadyEmitted: skillFlaggedThisCycle,
+        });
+        // 5c. Report the harness session (once per harness per proxy process —
+        // the reporter dedupes). This is what switches on branch/commit capture
+        // and the task-context cascade. With a local proxy the context lands on
+        // the proxy's own row, the one its traces are filed under; without one a
+        // `ses_` row is opened (see sessionReporter.ts).
+        await startHarnessSession({
+            controlPlaneUrl,
+            apiKey,
+            workspaceId,
+            harnessType: harness,
+            workspaceRoot,
+            ...(proxyInstanceId ? { proxyInstanceId } : {}),
+        });
+    }
     // 6. Update local integrity store
     const newFiles = {};
     for (const fh of fileHashes) {
@@ -318,48 +650,13 @@ async function runSyncIteration(ctx) {
         configVersion: config.configVersion,
         files: newFiles,
     });
-    // 6b. ContextGraph Indexing Scan & Sync (WS1: LLD #16)
-    if (adapterId) {
-        try {
-            const { BrainIndexer } = await import('./brainIndexer.js');
-            const { loadContextIntegrity, saveContextIntegrity } = await import('./integrityStore.js');
-            const scanResult = await BrainIndexer.scanWorkspace(workspaceRoot);
-            const contextIntegrity = await loadContextIntegrity(workspaceRoot);
-            const delta = BrainIndexer.computeDelta(scanResult, contextIntegrity);
-            if (delta.upserted.length > 0 || delta.deleted.length > 0) {
-                const syncUrl = `${controlPlaneUrl}/api/v1/context/sync`;
-                const res = await fetch(syncUrl, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${apiKey}`,
-                    },
-                    body: JSON.stringify({
-                        adapterId,
-                        delta,
-                    }),
-                    signal: AbortSignal.timeout(15_000),
-                });
-                if (res.ok) {
-                    const newContextFiles = {};
-                    for (const [filePath, file] of Object.entries(scanResult.files)) {
-                        newContextFiles[filePath] = file.hash;
-                    }
-                    await saveContextIntegrity(workspaceRoot, {
-                        lastSyncAt: newIso(),
-                        configVersion: config.configVersion,
-                        files: newContextFiles,
-                    });
-                }
-                else {
-                    console.warn(`[sync-daemon] ContextGraph sync failed: ${res.status} ${res.statusText}`);
-                }
-            }
-        }
-        catch (err) {
-            console.warn('[sync-daemon] ContextGraph sync error:', err);
-        }
-    }
+    // 6b. ContextGraph indexing — REMOVED.
+    //
+    // This block scanned the whole workspace every sync cycle and POSTed the
+    // delta to /api/v1/context/sync, an ingest stripped from the control plane
+    // with the Context Graph feature (commit 9cfc0200). Worse than dead: the
+    // integrity file is only written on a 2xx, so every cycle re-scanned and
+    // re-posted the same delta forever on every developer machine.
     // 6c. Hook event drain is now FSEvents-driven (see startSyncLoop).
     //     No per-iteration drain needed here; the chokidar watcher handles it.
     // 7. Invoke onSync callback
@@ -372,6 +669,7 @@ async function runSyncIteration(ctx) {
         sops: config.sops,
         proxyUrl: config.proxyUrl,
         harnesses,
+        harnessGovernanceInputs,
     };
     onSync?.(result);
     return result;
@@ -424,6 +722,40 @@ async function reportStatus(controlPlaneUrl, apiKey, workspaceId, harnessType, f
         console.warn(`[sync-daemon] reportStatus failed for ${harnessType}: ${res.status} ${res.statusText}`);
     }
 }
+/**
+ * Ack a SkillOpt config-edit apply outcome back to the control plane
+ * (TD-349) — POST /api/v1/skillopt/:suggestionId/apply-result.
+ *
+ * Same HTTP call shape as `reportGovernanceCoverageSnapshot`
+ * (configReader.ts): `fetch` + `AbortSignal.timeout(10_000)`, fully
+ * non-fatal. This ack closing the loop is important, but it must never be
+ * allowed to abort a sync cycle that otherwise succeeded — a dropped ack
+ * just means the suggestion re-syncs and gets acked again next cycle
+ * (getSyncConfig re-pushes 'applied' and 'apply_unconfirmed' rows alike).
+ */
+async function reportApplyResult(controlPlaneUrl, apiKey, suggestionId, result) {
+    try {
+        const res = await fetch(`${controlPlaneUrl}/api/v1/skillopt/${suggestionId}/apply-result`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                ok: result.ok,
+                perOperation: result.perOperation,
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            console.warn(`[sync-daemon] reportApplyResult failed for ${suggestionId} (${res.status}): ${body}`);
+        }
+    }
+    catch (err) {
+        console.warn(`[sync-daemon] reportApplyResult request failed for ${suggestionId}:`, err);
+    }
+}
 // ─── Helpers ─────────────────────────────────────────────────────────
 /**
  * Extract unique harness types from a sync config payload.
@@ -492,7 +824,7 @@ export async function syncOfflineTraces(controlPlaneUrl, apiKey) {
                 fs.renameSync(originalPath, syncingPath);
             }
             catch (renameErr) {
-                console.error(`[sync-daemon] Failed to lock/rename file ${file}:`, renameErr.message);
+                console.error(`[sync-daemon] Failed to lock/rename file ${file}:`, errorMessage(renameErr));
                 continue;
             }
             try {
@@ -526,7 +858,7 @@ export async function syncOfflineTraces(controlPlaneUrl, apiKey) {
                 console.log(`[sync-daemon] Successfully synced ${traces.length} offline traces back from ${file}.`);
             }
             catch (err) {
-                console.error(`[sync-daemon] Failed to sync offline traces back from ${file}:`, err.message);
+                console.error(`[sync-daemon] Failed to sync offline traces back from ${file}:`, errorMessage(err));
                 // Revert rename on failure to allow retry on next cycle
                 try {
                     if (fs.existsSync(syncingPath)) {
@@ -534,13 +866,13 @@ export async function syncOfflineTraces(controlPlaneUrl, apiKey) {
                     }
                 }
                 catch (revertErr) {
-                    console.error(`[sync-daemon] Failed to revert rename for ${file}:`, revertErr.message);
+                    console.error(`[sync-daemon] Failed to revert rename for ${file}:`, errorMessage(revertErr));
                 }
             }
         }
     }
     catch (err) {
-        console.error(`[sync-daemon] Failed to scan offline traces directory:`, err.message);
+        console.error(`[sync-daemon] Failed to scan offline traces directory:`, errorMessage(err));
     }
 }
 //# sourceMappingURL=syncLoop.js.map