@intutic/cli 2.1.0 → 2.3.0

package/dist/commands/connect.js

@@ -5,7 +5,6 @@
  * a real-time filesystem watcher for configuration drift detection,
  * and a 30-second HTTP polling loop as a secondary fallback.
  *
- * LLD #14 — connect.ts
  * HLD §3.14 — Real-Time State Mirroring
  *
  * @module
@@ -25,10 +24,12 @@ import { getAdapter } from '../harness/detector.js';
 import { printOnboardingGuide } from '../lib/onboarding.js';
 import { writeEnforcementState } from '../lib/enforcementState.js';
 import { reportDeviceState } from '../lib/deviceReport.js';
+import { reportMachineInventory, shouldReportInventoryThisIteration } from '../lib/inventory.js';
 import { parseChecksums, verifyChecksum } from '../lib/binaryChecksum.js';
 import { newIso } from '@intutic/id';
+import { HarnessType, rulesFileOf } from '@intutic/shared-types';
 import pc from 'picocolors';
-import { SyncWsClient, startWatcher, updatePreToolUseHooks, injectMcpServer, guardSettingsFile, warnIfDshCoverageGap, writeRuntimeEnv, refreshPolicySnapshot, refreshGateCaches, localHoldTokensFor, runComplianceProbes, drainHookEvents, drainReviewRequests, REVIEW_REQUESTS_LOG, syncOfflineTraces, TrajectoryMonitor, collectAgentReport, reportAgent, fetchLocalProxyInstanceId, startHarnessSession, endAllOpenSessions, } from '@intutic/sync-daemon';
+import { SyncWsClient, startWatcher, updatePreToolUseHooks, injectMcpServer, noteProxyUrl, guardPolicySnapshot, guardSettingsFile, isGuardedPath, warnIfDshCoverageGap, writeRuntimeEnv, refreshPolicySnapshot, refreshGateCaches, localHoldTokensFor, runComplianceProbes, drainHookEvents, drainReviewRequests, REVIEW_REQUESTS_LOG, syncOfflineTraces, TrajectoryMonitor, fetchLocalProxyInstanceId, endAllOpenSessions, applySkillOptEdits, reportHarnessAgents, captureAndUpload, shouldCaptureThisIteration, refreshDecisionsDigest, retireClaudeMdDigest, claudeCodeReadsAgentsMd, writeBundledSkills, clearImmutable, setImmutable, } from '@intutic/sync-daemon';
 import { watch } from 'chokidar';
 // Named, not default: under `module: Node16` TypeScript resolves ioredis's
 // default export to the module namespace rather than the class, so `new
@@ -61,20 +62,57 @@ function isPortInUse(port) {
     });
 }
 /**
- * Is this a path the tamper guard should inspect?
+ * Applies a synced configuration to each configured harness.
  *
- * Deliberately broad: `guardSettingsFile` already branches per harness, so the only
- * job here is to stop filtering out paths it knows how to handle.
+ * The gate is installed whatever rule sets the workspace has: it enforces the
+ * built-in protections, the destructive-command tier, group rules and holds,
+ * none of which need a rule set. Gating it on rule sets left a workspace with
+ * none, or with none targeting a harness, with that harness ungoverned. The
+ * rules file is written only when a rule set targets the harness, or on a
+ * forced sync.
+ *
+ * Harnesses that read the same file (Codex, Grok Build, OpenCode, Muse Code
+ * and others all read `AGENTS.md`) each get every rule set aimed at any of
+ * them that is configured here: one section, the same for every writer, so
+ * the last writer no longer replaces the others' rules.
+ *
+ * Claude Code reads its own `.claude/rules/` file at every launch, and also
+ * the workspace's `AGENTS.md` when there is no `CLAUDE.md` on the path (or
+ * the user chose `claude-md-and-agents-md`; see claudeAgentsMd.ts). When it
+ * does, a rule set aimed at both Claude Code and an `AGENTS.md` reader
+ * reaches it through `AGENTS.md`, so its own file leaves that rule set out
+ * rather than load it twice.
+ *
+ * @returns how many rule sets were written into rules files.
  */
-function isGovernedConfigPath(changedPath, filename) {
-    if (filename === 'settings.json' || filename === 'settings.local.json')
-        return true;
-    if (filename === 'hooks.json')
-        return true;
-    // Goose's immutable governance plugin.
-    if (changedPath.includes('intutic-governance'))
-        return true;
-    return false;
+export async function writeHarnessConfigs(harnesses, workspaceRoot, sops, proxyUrl, force) {
+    let written = 0;
+    const writtenFiles = new Set();
+    const agentsMdReaders = harnesses.filter((h) => rulesFileOf(h) === 'AGENTS.md');
+    const claudeFromAgentsMd = harnesses.includes(HarnessType.CLAUDE_CODE) && agentsMdReaders.length > 0 && (await claudeCodeReadsAgentsMd(workspaceRoot));
+    for (const harnessType of harnesses) {
+        const adapter = getAdapter(harnessType);
+        if (!adapter)
+            continue;
+        await adapter.installGate?.(workspaceRoot, proxyUrl);
+        const file = rulesFileOf(harnessType);
+        const readers = file === null ? [harnessType] : harnesses.filter((h) => rulesFileOf(h) === file);
+        const aimed = sops.filter((sop) => sop.harnessTargets.some((t) => readers.includes(t)));
+        const viaAgentsMd = harnessType === HarnessType.CLAUDE_CODE && claudeFromAgentsMd;
+        const targetSops = viaAgentsMd ? aimed.filter((sop) => !sop.harnessTargets.some((t) => agentsMdReaders.includes(t))) : aimed;
+        // Claude Code's own file is rewritten even when every rule set aimed at
+        // it now comes through AGENTS.md, so it stops carrying them.
+        if (aimed.length === 0 && !force)
+            continue;
+        if (!(await adapter.writeConfig(workspaceRoot, targetSops, proxyUrl)))
+            continue;
+        // A shared file counts once, however many of its readers wrote it.
+        if (file === null || !writtenFiles.has(file))
+            written += targetSops.length;
+        if (file !== null)
+            writtenFiles.add(file);
+    }
+    return written;
 }
 /**
  * Asset names MUST match publish.yml's build-rust-proxy matrix
@@ -262,7 +300,7 @@ export async function runConnect(opts) {
     // 2. AbortController for clean shutdown
     let proxyProc = null;
     const ac = new AbortController();
-    // TD-484: this handler used to abort the loop and hope. The process stayed
+    // This handler used to abort the loop and hope. The process stayed
     // alive for hours. `createShutdownHandler` adds the exit deadline and the
     // second-signal exit; `terminateChild` escalates to SIGKILL.
     const shutdown = createShutdownHandler({
@@ -453,24 +491,57 @@ export async function runConnect(opts) {
     // when the config version moved: policy changes without the config version
     // changing, and a guardrail promoted, a hold approved or an egress mode
     // flipped mid-session used to reach a connected machine only on restart —
-    // this function was called once, at startup (TD-488). Parity with the
-    // daemon's own loop (`syncLoop.ts`'s Steps 0b–0d). None of these throw.
+    // this function was called once, at startup. None of these throw.
     //
     // The snapshot also carries this workspace's `review_before:` tokens as hold
     // rules (synced SOPs, settings and local `.intutic/sops`), so every gate —
-    // not only the Claude Code hook — holds on them (TD-474 item 4).
-    async function refreshGateCachesForConnect() {
+    // not only the Claude Code hook — holds on them.
+    //
+    // First, the snapshot's self-heal: a snapshot changed while the daemon was
+    // stopped is put back to the last verified copy, and reported, before the
+    // refresh replaces it. With `checkSnapshot` false the caller is that check.
+    async function refreshGateCachesForConnect(checkSnapshot = true) {
+        if (checkSnapshot)
+            await guardPolicySnapshot(safeConfig.workspaceRoot, async () => { });
         const localHoldTokens = await localHoldTokensFor(safeConfig.workspaceRoot, lastCachedConfig?.sops ?? [], lastCachedConfig?.settings, safeConfig.harnesses);
         const landed = await refreshGateCaches({ controlPlaneUrl, apiKey: safeCreds.apiKey, workspaceId: safeCreds.workspaceId, localHoldTokens });
         if (!landed.snapshot)
             log.dim('Policy snapshot refresh failed (will retry next sync); built-in protections are unaffected.');
     }
+    // The rules files the adapters write, absolute. `configFileName` is
+    // relative to the workspace for most harnesses and absolute for the few
+    // that keep their config in the home directory.
+    const rulesFilePaths = () => safeConfig.harnesses
+        .map((h) => getAdapter(h)?.configFileName)
+        .filter((f) => Boolean(f))
+        .map((f) => node_path.resolve(safeConfig.workspaceRoot, f));
+    // Whether Claude Code read the workspace's AGENTS.md at the last sync. A
+    // CLAUDE.md added or removed (or the user's Project instructions setting
+    // changed) moves rule sets between AGENTS.md and Claude Code's own file, so
+    // a change rewrites the rules files as a new config would.
+    let lastClaudeFromAgentsMd;
     // 3. Define configuration applier function
     async function applySyncConfig(syncConfig, force = false) {
         let sopsWritten = 0;
         lastCachedConfig = syncConfig;
         await refreshGateCachesForConnect();
-        if (syncConfig.configVersion > localConfigVersion || force) {
+        const claudeFromAgentsMd = safeConfig.harnesses.includes(HarnessType.CLAUDE_CODE)
+            ? await claudeCodeReadsAgentsMd(safeConfig.workspaceRoot)
+            : false;
+        const claudeDeliveryMoved = lastClaudeFromAgentsMd !== undefined && claudeFromAgentsMd !== lastClaudeFromAgentsMd;
+        lastClaudeFromAgentsMd = claudeFromAgentsMd;
+        // Write-protect (`bypassEnforcementTier: 'immutable'`, macOS): the rules
+        // files carry the user-immutable flag between cycles, so it comes off
+        // before anything below writes them and goes back on afterwards. It also
+        // comes off whenever the config moved, so a workspace that switched away
+        // from write-protect is not left with files nothing can rewrite.
+        const writeProtect = syncConfig.settings?.bypassEnforcementTier === 'immutable';
+        const configMoved = syncConfig.configVersion > localConfigVersion || force || claudeDeliveryMoved;
+        if (writeProtect || configMoved) {
+            for (const file of rulesFilePaths())
+                await clearImmutable(file);
+        }
+        if (configMoved) {
             log.info(`Applying configuration v${syncConfig.configVersion}...`);
             // Load and compile local SOP entries
             const localSopEntries = [];
@@ -524,19 +595,11 @@ export async function runConnect(opts) {
                 }
             }
             const combinedSops = [...syncConfig.sops, ...localSopEntries];
-            // a. Write configs for all active harnesses
-            for (const harnessType of safeConfig.harnesses) {
-                const adapter = getAdapter(harnessType);
-                if (!adapter)
-                    continue;
-                const targetSops = combinedSops.filter((sop) => sop.harnessTargets.includes(harnessType));
-                if (targetSops.length === 0 && !force)
-                    continue;
-                const written = await adapter.writeConfig(safeConfig.workspaceRoot, targetSops, syncConfig.proxyUrl);
-                if (written) {
-                    sopsWritten += targetSops.length;
-                }
-            }
+            // a. Write configs for all active harnesses. The proxy URL is recorded
+            // first: `intutic disconnect` recognises the base-URL settings it is
+            // written into by it.
+            await noteProxyUrl(syncConfig.proxyUrl);
+            sopsWritten += await writeHarnessConfigs(safeConfig.harnesses, safeConfig.workspaceRoot, combinedSops, syncConfig.proxyUrl, force);
             // b. Invalidate/update Claude Code hooks and settings
             if (safeConfig.harnesses.includes('claude-code')) {
                 try {
@@ -546,19 +609,54 @@ export async function runConnect(opts) {
                     log.warn(`Failed to update Claude Code hooks: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
-            // c. Inject + proxy-wrap MCP servers across all supported harnesses
-            try {
-                await injectMcpServer(safeConfig.workspaceRoot, safeCreds.workspaceId);
-            }
-            catch (err) {
-                log.warn(`Failed to inject MCP server configs: ${err instanceof Error ? err.message : String(err)}`);
-            }
             localConfigVersion = syncConfig.configVersion;
             // Mirror workspace settings locally so spawn-time policies (like
             // allowLocalMemoryVaults) apply on the next connect without a fetch.
             safeConfig.settings = syncConfig.settings;
             saveConfig({ ...safeConfig, configVersion: localConfigVersion, settings: syncConfig.settings });
         }
+        // c. Inject + proxy-wrap MCP servers across all supported harnesses, on
+        // every cycle rather than only when the config moved: a server a user adds
+        // to a harness config after `connect` started is wrapped on the next cycle.
+        // The writes are write-if-changed, so an unchanged config costs no write.
+        try {
+            await injectMcpServer(safeConfig.workspaceRoot, safeCreds.workspaceId, { skip: safeConfig.disconnectedHarnesses });
+        }
+        catch (err) {
+            log.warn(`Failed to inject MCP server configs: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // d. SkillOpt edits the control plane queued for this workspace, acked
+        // back so a suggestion reaches `applied` only once it is on disk. All of
+        // them again when the rules files were just rewritten, which drops every
+        // overlay. Before the integrity hashes below, so the drift watcher does
+        // not take the edit for tampering.
+        await applySkillOptEdits({
+            workspaceRoot: safeConfig.workspaceRoot,
+            controlPlaneUrl,
+            apiKey: safeCreds.apiKey,
+            appliedEdits: syncConfig.appliedEdits,
+            bypassEnforcementTier: syncConfig.settings?.bypassEnforcementTier,
+            reapplyAll: configMoved,
+        });
+        // e. The governed decisions log, opt-in (`decisionsLogEnabled`, off by
+        // default), into each harness's instructions file. Also before the hashes:
+        // it writes into shared files such as AGENTS.md, whose rules section they
+        // cover. The section earlier versions put in CLAUDE.md comes out whether
+        // or not the log is on.
+        await retireClaudeMdDigest(safeConfig.workspaceRoot);
+        if (syncConfig.settings?.decisionsLogEnabled) {
+            await refreshDecisionsDigest({
+                controlPlaneUrl,
+                apiKey: safeCreds.apiKey,
+                workspaceId: safeCreds.workspaceId,
+                workspaceRoot: safeConfig.workspaceRoot,
+                harnesses: safeConfig.harnesses,
+            });
+        }
+        if (writeProtect) {
+            for (const file of rulesFilePaths())
+                await setImmutable(file);
+        }
         // c. Compute file hashes + update integrity store
         const fileHashes = [];
         const canonicalHashes = {};
@@ -695,7 +793,7 @@ export async function runConnect(opts) {
                 proxyStatus = 'unhealthy';
                 if (ac.signal.aborted) {
                     // Shutting down: the proxy is gone because we stopped it. Re-spawning
-                    // it here would leave an orphan holding the port (TD-484).
+                    // it here would leave an orphan holding the port.
                     proxyStatus = 'stopped';
                 }
                 else if (proxyProc) {
@@ -762,7 +860,7 @@ export async function runConnect(opts) {
         catch (err) {
             log.warn(`Failed to send daemon heartbeat: ${err instanceof Error ? err.message : String(err)}`);
         }
-        // g. Enforcement device visibility (post-strip gap #2, LLD #63
+        // g. Enforcement device visibility (post-strip gap #2, egress
         // hardening) — the "interval" half of "continuous compliance": this
         // loop already runs unprivileged, as the real user, on a timer, and
         // already just computed sslTrustStatus above for its own DR-healing
@@ -797,7 +895,7 @@ export async function runConnect(opts) {
                 mcpProxyFailBehavior: syncConfig.settings?.mcpProxyFailBehavior,
                 mcpProxyMode: syncConfig.settings?.mcpProxyMode,
                 bypassEnforcementTier: syncConfig.settings?.bypassEnforcementTier,
-                // Shared by the MCP proxies for their session window (Wave 5.3, TD-437) — only when it is running.
+                // Shared by the MCP proxies for their session window — only when it is running.
                 valkeyUrl: valkeyResult.running ? valkeyUrl : undefined,
             });
         }
@@ -828,7 +926,7 @@ export async function runConnect(opts) {
             log.warn(`Compliance probes failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         }
     };
-    // Drains BOTH logs, matching `services/sync-daemon/src/syncLoop.ts`.
+    // Drains BOTH logs.
     //
     // This drained hook events only. `intutic connect` runs the daemon in-process,
     // so under the CLI runtime a `review_before` hold still blocked the tool
@@ -899,7 +997,7 @@ export async function runConnect(opts) {
             controlPlaneUrl,
             apiKey: safeCreds.apiKey,
             workspaceId: safeCreds.workspaceId,
-            // Shared by the MCP proxies for their session window (Wave 5.3, TD-437) — only when it is running.
+            // Shared by the MCP proxies for their session window — only when it is running.
             valkeyUrl: valkeyResult.running ? valkeyUrl : undefined,
         });
     }
@@ -923,6 +1021,14 @@ export async function runConnect(opts) {
             'will not apply until the next successful sync. Built-in protections are unaffected.');
     }
     await refreshGateCachesForConnect();
+    // The bundled rule-author agent skill, written only when absent so a local
+    // edit is never overwritten.
+    try {
+        await writeBundledSkills(safeConfig.workspaceRoot);
+    }
+    catch (err) {
+        log.dim(`Could not write the bundled agent skill: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // Sync offline traces back to PostgreSQL on startup
     try {
         await syncOfflineTraces(controlPlaneUrl, safeCreds.apiKey);
@@ -1016,7 +1122,7 @@ export async function runConnect(opts) {
     const drainSafetyTimer = setInterval(runDrain, 60_000);
     // Run initial compliance check on startup
     await runProbes();
-    // dsh coverage-gap visibility (TD-370): once at startup, not every poll
+    // dsh coverage-gap visibility: once at startup, not every poll
     // tick — the gap only changes state on the user's first `dsh --profile
     // <name>` run, which the filesystem watcher below reacts to immediately
     // via settingsGuard.ts's isDshProfilesRoot `addDir` handling. Only worth
@@ -1062,20 +1168,17 @@ export async function runConnect(opts) {
         }
         // B. Tamper detection for every governed config, not just Claude Code's.
         //
-        // This used to filter on `filename === 'settings.json'`, which silently disabled
-        // five of the six branches inside guardSettingsFile: the Cursor, Windsurf, Cline
-        // and OpenHands restores all key off `hooks.json`, and the Goose
-        // governance-plugin override incident keys off a path containing
-        // `intutic-governance`. None of those basenames could ever reach the guard, so a
-        // tampered hooks file on any harness but Claude Code was a no-op — and a tampered
-        // Windsurf/VS Code/Gemini settings file passed the basename test only to fall
-        // through and log `settings_intact`.
-        //
-        // Route anything on the governed list to the guard and let it decide.
-        if (isGovernedConfigPath(changedPath, filename)) {
+        // Routed on the guard's own watch list. A filter on file names here, first
+        // `settings.json` and later `settings.json`/`hooks.json`/`intutic-governance`,
+        // kept the guard from ever seeing the paths it restores under other names:
+        // a gate script, Cline's PreToolUse, OpenClaw's openclaw.json, Muse's
+        // managed-hooks file and every dsh profile patch.
+        if (isGuardedPath(changedPath, safeConfig.workspaceRoot)) {
             try {
                 const sops = lastCachedConfig?.sops ?? [];
-                const tampered = await guardSettingsFile(changedPath, safeConfig.workspaceRoot, sops);
+                // The proxy URL too: the restored gate scripts carry it, and an empty
+                // one would be written into them.
+                const tampered = await guardSettingsFile(changedPath, safeConfig.workspaceRoot, sops, lastCachedConfig?.proxyUrl ?? '', undefined, new Set(safeConfig.disconnectedHarnesses ?? []), () => refreshGateCachesForConnect(false));
                 if (tampered) {
                     log.warn(`[Security] Governance settings tamper detected and restored: ${changedPath}`);
                     wsClient.send({
@@ -1092,8 +1195,9 @@ export async function runConnect(opts) {
             }
             return;
         }
-        // B. Handle governed harness file drift detection
-        const matchingHarness = safeConfig.harnesses.find((h) => getAdapter(h)?.configFileName === filename);
+        // B. Handle governed harness file drift detection. By path, not
+        // basename: rules files sit in directories (`.cursor/rules/…`).
+        const matchingHarness = safeConfig.harnesses.find((h) => getAdapter(h)?.configFileName === relativePath.split(node_path.sep).join('/'));
         if (!matchingHarness)
             return;
         const adapter = getAdapter(matchingHarness);
@@ -1105,6 +1209,20 @@ export async function runConnect(opts) {
             return;
         const canonical = integrity.files[adapter.configFileName] ?? '';
         if (currentHash !== canonical) {
+            // Record only (`bypassEnforcementTier: 'alert-only'`): the edit stays,
+            // and the drift report below is the record.
+            const tier = (lastCachedConfig?.settings ?? safeConfig.settings)?.bypassEnforcementTier;
+            if (tier === 'alert-only') {
+                log.warn(`Governed config file "${filename}" was edited by hand; recording the drift and leaving the edit in place.`);
+                wsClient.send({
+                    type: 'drift_report',
+                    harnessType: adapter.type,
+                    filePath: adapter.configFileName,
+                    localHash: currentHash || '',
+                    canonicalHash: canonical,
+                });
+                return;
+            }
             log.warn(`Governed config file "${filename}" modification detected! Reverting to approved baseline...`);
             // Backup drifted version first
             try {
@@ -1138,6 +1256,7 @@ export async function runConnect(opts) {
         }
     });
     // 6. Secondary fallback HTTP poll loop
+    let pollIteration = 0;
     while (!ac.signal.aborted) {
         try {
             const syncConfig = await client.fetchConfig(safeCreds.workspaceId);
@@ -1154,40 +1273,56 @@ export async function runConnect(opts) {
                 log.dim(`Offline trace sync failed (will retry next poll): ${err instanceof Error ? err.message : String(err)}`);
             }
             // Register agents + report one session per harness (the reporter
-            // dedupes per run and per proxy process). connect's inline loop bypassed
-            // both, leaving the dashboard graph empty for the primary user path.
-            // The local proxy's instance id is read once per iteration: with it the
-            // harness's git/task context lands on the proxy's own session row, the
-            // one its traces are filed under (TD-231, Wave 5.6).
+            // dedupes per run and per proxy process), and turn this cycle's skill
+            // scan findings into `skill_flagged` events. The local proxy's instance
+            // id is read once per iteration: with it the harness's git/task context
+            // lands on the proxy's own session row, the one its traces are filed
+            // under.
             const proxyInstanceId = safeConfig.harnesses.length > 0 ? await fetchLocalProxyInstanceId() : null;
-            for (const harnessType of safeConfig.harnesses) {
+            const { governanceInputs, failures } = await reportHarnessAgents({
+                controlPlaneUrl,
+                apiKey: safeCreds.apiKey,
+                workspaceId: safeCreds.workspaceId,
+                workspaceRoot: safeConfig.workspaceRoot,
+                harnesses: safeConfig.harnesses,
+                allowLocalVaults: syncConfig.settings?.allowLocalMemoryVaults,
+                proxyInstanceId,
+            });
+            for (const { harness, error } of failures) {
+                log.dim(`Agent report/session for harness '${harness}' failed: ${error}`);
+            }
+            // Every few minutes, the machine's AI inventory for the org-wide view:
+            // every harness the detection rules find, connected or not, with its
+            // gate state, and the MCP servers and skill bundles on the machine.
+            if (shouldReportInventoryThisIteration(pollIteration)) {
+                const inventory = await reportMachineInventory({
+                    controlPlaneUrl,
+                    apiKey: safeCreds.apiKey,
+                    workspaceRoot: safeConfig.workspaceRoot,
+                    configured: safeConfig.harnesses,
+                    disconnected: safeConfig.disconnectedHarnesses,
+                    cliVersion: cliPkgVersion,
+                });
+                if (!inventory.reported)
+                    log.dim(`AI inventory report not sent (will retry): ${inventory.reason}`);
+            }
+            // Every Nth poll, capture the rules files that changed for the config
+            // history. Content goes only when this poll's settings have
+            // `configBodyUpload` on; otherwise path, hash, size and time.
+            if (shouldCaptureThisIteration(pollIteration)) {
                 try {
-                    const report = await collectAgentReport({
-                        workspaceRoot: process.cwd(),
-                        harnessType,
-                        configSynced: true,
-                        dlpEnabled: true,
-                        policyEnforced: true,
-                        allowLocalVaults: syncConfig.settings?.allowLocalMemoryVaults,
-                    });
-                    await reportAgent(controlPlaneUrl, safeCreds.apiKey, safeCreds.workspaceId, report);
-                    await startHarnessSession({
+                    await captureAndUpload({
                         controlPlaneUrl,
                         apiKey: safeCreds.apiKey,
                         workspaceId: safeCreds.workspaceId,
-                        harnessType,
-                        workspaceRoot: process.cwd(),
-                        ...(proxyInstanceId ? { proxyInstanceId } : {}),
+                        workspaceRoot: safeConfig.workspaceRoot,
+                        harnesses: safeConfig.harnesses,
+                        includeContent: syncConfig.settings?.configBodyUpload === true,
+                        governanceInputs,
                     });
                 }
                 catch (err) {
-                    // Per-harness isolation is deliberate: one harness failing to register
-                    // must not stop the others or abort the poll iteration. Silence was
-                    // not deliberate — fetchConfig already succeeded above, so a failure
-                    // here means the control plane accepted the config read and rejected
-                    // the agent report, which is exactly the "dashboard graph is empty"
-                    // symptom this loop was added to fix. Report it so it is diagnosable.
-                    log.dim(`Agent report/session for harness '${harnessType}' failed: ${err instanceof Error ? err.message : String(err)}`);
+                    log.dim(`Config capture failed (will retry): ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
             // Run compliance probes on each iteration
@@ -1197,6 +1332,7 @@ export async function runConnect(opts) {
             log.error(`Sync iteration failed: ${err instanceof Error ? err.message : String(err)}`);
             log.dim(`Retrying in ${pollInterval / 1000}s...`);
         }
+        pollIteration++;
         // Sleep until next interval (AbortSignal-aware)
         await new Promise((resolve) => {
             const timer = setTimeout(resolve, pollInterval);