@@ -319,10 +319,12 @@ export async function runAgenticOnboard(
     let terminalResult: AgenticOnboardResult | null = null;
 
     const handleLine = (line: string) => {
-      const result = translateOnboardPayload(line);
-      const parsed = safeParse(line);
-      if (parsed) writeAiOutput(parsed as any);
-      if (result) terminalResult = result;
+      const parsed = tryParseObject(line);
+      if (parsed) {
+        writeAiOutput(parsed as any);
+        const result = translateOnboardPayload(line);
+        if (result) terminalResult = result;
+      }
     };
 
     child.stdout.on('data', (chunk: Buffer) => {
@@ -355,12 +357,10 @@ export async function runAgenticOnboard(
       if (lineBuf.trim()) handleLine(lineBuf);
 
       if (!terminalResult && fullStdout.trim()) {
-        const blob = extractJsonObject(fullStdout);
-        if (blob) {
-          const result = translateOnboardPayload(blob);
+        for (const payload of extractJsonPayloads(fullStdout)) {
+          const result = translateOnboardPayload(JSON.stringify(payload));
           if (result) {
-            const parsed = safeParse(blob);
-            if (parsed) writeAiOutput(parsed as any);
+            writeAiOutput(payload as any);
             terminalResult = result;
           }
         }
@@ -385,29 +385,58 @@ export async function runAgenticOnboard(
   });
 }
 
-function safeParse(line: string): Record<string, unknown> | null {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    return typeof parsed === 'object' && parsed !== null ? parsed : null;
-  } catch {
-    return null;
+/**
+ * Parse every top-level JSON object out of a stdout buffer.
+ *
+ * Handles three shapes from `nx-cloud onboard connect-workspace`:
+ *  - NDJSON: one parseable object per line (target after CLOUD-4496)
+ *  - Pretty-printed multi-line: `{` and matching `}` at column 0 (current bin)
+ *  - Either, with non-JSON noise lines interleaved (always possible — a stray
+ *    `output.note(...)` writing to stdout will leak through any contract)
+ *
+ * "Top-level" = line starts with `{` or `}` at column 0. Inner braces inside
+ * a pretty-printed object are indented and ignored.
+ */
+export function extractJsonPayloads(
+  text: string
+): Array<Record<string, unknown>> {
+  const out: Array<Record<string, unknown>> = [];
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith('{')) {
+      i++;
+      continue;
+    }
+    const single = tryParseObject(lines[i]);
+    if (single) {
+      out.push(single);
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    while (j < lines.length && !lines[j].startsWith('}')) j++;
+    if (j < lines.length) {
+      const multi = tryParseObject(lines.slice(i, j + 1).join('\n'));
+      if (multi) {
+        out.push(multi);
+        i = j + 1;
+        continue;
+      }
+    }
+    i++;
   }
+  return out;
 }
 
-/**
- * Slice the JSON object out of a buffer that may contain human-readable noise
- * before it. Workaround for CLOUD-4496 — drop once the bin emits clean `--json`.
- */
-export function extractJsonObject(text: string): string | null {
-  const start = text.indexOf('{');
-  const end = text.lastIndexOf('}');
-  if (start === -1 || end < start) return null;
-  const candidate = text.slice(start, end + 1);
+function tryParseObject(text: string): Record<string, unknown> | null {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
   try {
-    JSON.parse(candidate);
-    return candidate;
+    const v = JSON.parse(trimmed);
+    return typeof v === 'object' && v !== null && !Array.isArray(v)
+      ? (v as Record<string, unknown>)
+      : null;
   } catch {
     return null;
   }
 
@@ -1,4 +1,7 @@
-import { extractJsonObject, translateOnboardPayload } from './agentic-onboard';
+import {
+  extractJsonPayloads,
+  translateOnboardPayload,
+} from './agentic-onboard';
 
 describe('translateOnboardPayload', () => {
   it('returns null for empty or whitespace lines', () => {
@@ -232,47 +235,157 @@ describe('translateOnboardPayload', () => {
   });
 });
 
-describe('extractJsonObject', () => {
-  it('returns null when there is no JSON object', () => {
-    expect(extractJsonObject('')).toBeNull();
-    expect(extractJsonObject('just human text, no braces')).toBeNull();
+describe('extractJsonPayloads', () => {
+  it('returns [] for empty or whitespace-only input', () => {
+    expect(extractJsonPayloads('')).toEqual([]);
+    expect(extractJsonPayloads('   \n\n  ')).toEqual([]);
   });
 
-  it('extracts a flat JSON object from a clean buffer', () => {
-    expect(extractJsonObject('{"a":1}')).toBe('{"a":1}');
+  it('returns [] when there is no JSON', () => {
+    expect(extractJsonPayloads('just human text, no braces')).toEqual([]);
+    expect(
+      extractJsonPayloads(
+        ' NX   Updating nx.json\n\nNo JSON in this output anywhere.'
+      )
+    ).toEqual([]);
   });
 
-  it('extracts the JSON blob when preceded by human-readable text', () => {
-    const buf = `
- NX   Updating nx.json with Nx Cloud ID
+  // NDJSON case (target shape after CLOUD-4496).
+  it('parses a single NDJSON line', () => {
+    expect(extractJsonPayloads('{"stage":"configuring"}')).toEqual([
+      { stage: 'configuring' },
+    ]);
+  });
+
+  it('parses multiple NDJSON lines in order', () => {
+    const buf = [
+      '{"stage":"configuring","message":"Connecting..."}',
+      '{"success":true,"workspace":{"id":"w","nxCloudId":"abc"},"configWritten":true}',
+    ].join('\n');
+    expect(extractJsonPayloads(buf)).toEqual([
+      { stage: 'configuring', message: 'Connecting...' },
+      {
+        success: true,
+        workspace: { id: 'w', nxCloudId: 'abc' },
+        configWritten: true,
+      },
+    ]);
+  });
 
-Your nx.json has been updated to use an Nx Cloud ID for authentication.
+  it('parses NDJSON with non-JSON noise interleaved', () => {
+    const buf = [
+      ' NX   Some bin output',
+      '{"stage":"configuring"}',
+      'plain text leak',
+      '{"success":true,"workspace":{"nxCloudId":"abc"}}',
+      '',
+    ].join('\n');
+    expect(extractJsonPayloads(buf)).toEqual([
+      { stage: 'configuring' },
+      { success: true, workspace: { nxCloudId: 'abc' } },
+    ]);
+  });
 
-{
+  // Multi-line pretty-printed case (current bin via CLOUD-4496 workaround).
+  it('parses a single multi-line pretty-printed JSON object', () => {
+    const buf = `{
   "success": true,
   "workspace": {
     "id": "abc",
     "nxCloudId": "abc123"
   },
   "configWritten": true
 }`;
-    const blob = extractJsonObject(buf);
-    expect(JSON.parse(blob!)).toEqual({
-      success: true,
-      workspace: { id: 'abc', nxCloudId: 'abc123' },
-      configWritten: true,
-    });
+    expect(extractJsonPayloads(buf)).toEqual([
+      {
+        success: true,
+        workspace: { id: 'abc', nxCloudId: 'abc123' },
+        configWritten: true,
+      },
+    ]);
   });
 
-  it('ignores braces inside JSON string values', () => {
-    expect(extractJsonObject('{"msg":"hello {world}","ok":true}')).toBe(
-      '{"msg":"hello {world}","ok":true}'
-    );
+  it('parses multi-line JSON preceded by human-readable noise', () => {
+    const buf = `
+ NX   Updating nx.json with Nx Cloud ID
+
+Your nx.json has been updated.
+
+{
+  "success": true,
+  "workspace": { "nxCloudId": "abc" },
+  "configWritten": true
+}`;
+    expect(extractJsonPayloads(buf)).toEqual([
+      {
+        success: true,
+        workspace: { nxCloudId: 'abc' },
+        configWritten: true,
+      },
+    ]);
   });
 
-  it('handles escaped quotes inside strings without losing brace tracking', () => {
-    expect(extractJsonObject('{"a":"a \\"quoted\\" }","b":1}')).toBe(
-      '{"a":"a \\"quoted\\" }","b":1}'
-    );
+  it('parses multi-line JSON followed by trailing noise', () => {
+    const buf = `{
+  "success": true,
+  "workspace": { "nxCloudId": "abc" }
+}
+NX   Some trailing message`;
+    expect(extractJsonPayloads(buf)).toEqual([
+      { success: true, workspace: { nxCloudId: 'abc' } },
+    ]);
+  });
+
+  // Mixed shapes — multi-line followed by NDJSON, etc.
+  it('parses a mix of multi-line JSON and NDJSON in the same buffer', () => {
+    const buf = `{"stage":"configuring"}
+{
+  "success": true,
+  "workspace": { "nxCloudId": "abc" }
+}
+{"trailing":"event"}`;
+    expect(extractJsonPayloads(buf)).toEqual([
+      { stage: 'configuring' },
+      { success: true, workspace: { nxCloudId: 'abc' } },
+      { trailing: 'event' },
+    ]);
+  });
+
+  // Robustness against JSON content that itself contains braces.
+  it('treats indented inner braces as part of the multi-line object', () => {
+    // The inner `{`/`}` are indented (column > 0), so they don't terminate.
+    const buf = `{
+  "workspace": {
+    "nested": { "deep": true }
+  }
+}`;
+    expect(extractJsonPayloads(buf)).toEqual([
+      { workspace: { nested: { deep: true } } },
+    ]);
+  });
+
+  it('handles braces inside JSON string values (single-line)', () => {
+    expect(extractJsonPayloads('{"msg":"hello {world}","ok":true}')).toEqual([
+      { msg: 'hello {world}', ok: true },
+    ]);
+  });
+
+  // Failure modes — should not throw, just return [].
+  it('skips truncated multi-line JSON (no closing })', () => {
+    const buf = `{
+  "success": true,
+  "workspace": { "nxCloudId": "abc" }`;
+    expect(extractJsonPayloads(buf)).toEqual([]);
+  });
+
+  it('skips malformed JSON without crashing', () => {
+    expect(extractJsonPayloads('{not valid json}')).toEqual([]);
+    expect(extractJsonPayloads('{\n  "success": true,\n  bad,\n}')).toEqual([]);
+  });
+
+  it('rejects non-object top-level values (arrays, primitives)', () => {
+    // Bin only emits objects; arrays/strings would be a contract violation.
+    expect(extractJsonPayloads('[1,2,3]')).toEqual([]);
+    expect(extractJsonPayloads('"just a string"')).toEqual([]);
   });
 });