copilotkit 4.9.50 → 4.9.60

package/index.js

@@ -96,14 +96,14 @@ function getTelemetryEndpointUrl() {
 }
 function getBuildInfo() {
   return {
-    version: true ? "4.9.50" : "dev",
-    buildNumber: true ? "34486444519" : "dev",
-    commitSha: true ? "1e703c3c476af7d0a52f801e34fbce2997f6a926" : "dev",
+    version: true ? "4.9.60" : "dev",
+    buildNumber: true ? "34616405214" : "dev",
+    commitSha: true ? "5f0f9a7cf15492544f1341f562fa5cd55387099c" : "dev",
     copilotKitCommit: getTemplateRef()
   };
 }
 function getTemplateRef() {
-  return true ? "380ad1220a7bc78104baedc469c4d086c8910494" : "main";
+  return true ? "d1584b840f904674b470be5d2b16c4ccca99c4f4" : "main";
 }
 function getC15tBackendUrl() {
   return true ? "https://calm-hazelnut-joy-copilotkit.inth.app" : "";
@@ -28868,6 +28868,57 @@ function readOnboardingRoute(dependencies) {
     return [];
   return stored.route;
 }
+function readStoredProofs(store, key) {
+  const stored = store.get(key);
+  if (typeof stored !== "object" || stored === null)
+    return void 0;
+  if (typeof stored.runId !== "string")
+    return void 0;
+  return typeof stored.proofs === "object" && stored.proofs !== null ? stored : void 0;
+}
+function recordProofOutcome(dependencies, runId, step, proof) {
+  const key = stateKey("proof", resolveAnchoredRoot(dependencies));
+  const stored = readStoredProofs(dependencies.store, key);
+  const previous = stored?.runId === runId ? stored.proofs : {};
+  dependencies.store.set(key, {
+    runId,
+    proofs: { ...previous, [step]: proof }
+  });
+}
+function readProofOutcome(dependencies, step) {
+  const root2 = resolveAnchoredRoot(dependencies);
+  const stored = readStoredProofs(dependencies.store, stateKey("proof", root2));
+  if (stored === void 0)
+    return void 0;
+  const bound = readBoundRun(dependencies.store, root2);
+  if (bound.state === "live" && bound.runId !== stored.runId)
+    return void 0;
+  return stored.proofs[step];
+}
+function readStoredCodingAgent(store, key) {
+  const stored = store.get(key);
+  if (typeof stored !== "object" || stored === null)
+    return void 0;
+  if (typeof stored.runId !== "string")
+    return void 0;
+  return typeof stored.codingAgent === "string" ? stored : void 0;
+}
+function recordCodingAgent(dependencies, runId, codingAgent) {
+  dependencies.store.set(stateKey("agent", resolveAnchoredRoot(dependencies)), {
+    codingAgent: normalizeCodingAgent(codingAgent),
+    runId
+  });
+}
+function readCodingAgent(dependencies) {
+  const root2 = resolveAnchoredRoot(dependencies);
+  const stored = readStoredCodingAgent(dependencies.store, stateKey("agent", root2));
+  if (stored === void 0)
+    return void 0;
+  const bound = readBoundRun(dependencies.store, root2);
+  if (bound.state === "live" && bound.runId !== stored.runId)
+    return void 0;
+  return stored.codingAgent;
+}
 function readOnboardingRunId(dependencies) {
   try {
     const bound = readBoundRun(
@@ -28890,21 +28941,6 @@ function readOnboardingIntent(dependencies) {
     return void 0;
   }
 }
-function resolveOnboardingRun(dependencies) {
-  const root2 = resolveAnchoredRoot(dependencies);
-  const bound = readBoundRun(dependencies.store, root2);
-  if (bound.state === "live") {
-    return {
-      runId: bound.runId,
-      started: false,
-      idOrigin: "minted",
-      ...bound.intent === void 0 ? {} : { intent: bound.intent }
-    };
-  }
-  const generatedRun = mintRunId(dependencies);
-  dependencies.store.set(stateKey("run", root2), generatedRun);
-  return { runId: generatedRun, started: true, idOrigin: "minted" };
-}
 function startOnboardingRun(dependencies, requestedRunId, requestedIntent) {
   if (requestedIntent !== void 0 && !ONBOARDING_INTENT_PATTERN.test(requestedIntent)) {
     throw new Error("Requested onboarding intent is invalid");
@@ -29761,7 +29797,7 @@ var require_redact = __commonJS({
       } = options;
       validatePaths(paths);
       const pathStructure = buildPathStructure(paths);
-      return function redact(obj) {
+      return function redact2(obj) {
         if (strict2 && (obj === null || typeof obj !== "object")) {
           if (obj === null || obj === void 0) {
             return serialize3 ? serialize3(obj) : obj;
@@ -33238,7 +33274,7 @@ var require_pino = __commonJS({
       if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0)
         opts.level = opts.level.toLowerCase();
       const {
-        redact,
+        redact: redact2,
         crlf,
         serializers: serializers2,
         timestamp: timestamp2,
@@ -33272,8 +33308,8 @@ var require_pino = __commonJS({
       const stringifyFn = stringify4.bind({
         [stringifySafeSym]: stringifySafe
       });
-      const stringifiers = redact ? redaction(redact, stringifyFn) : {};
-      const formatOpts = redact ? { stringify: stringifiers[redactFmtSym] } : { stringify: stringifyFn };
+      const stringifiers = redact2 ? redaction(redact2, stringifyFn) : {};
+      const formatOpts = redact2 ? { stringify: stringifiers[redactFmtSym] } : { stringify: stringifyFn };
       const end = "}" + (crlf ? "\r\n" : "\n");
       const coreChindings = asChindings.bind(null, {
         [chindingsSym]: "",
@@ -91416,6 +91452,19 @@ function describeCredentialWriteDirectory(dir, ceilingDir) {
   return `Wrote the project key to ${envPath}. ${subject} ${named} ${verb} env files from its own directory, so re-run \`copilotkit project select\` from ${target} to put the key where the app process reads it.
 `;
 }
+function envFileLoaderDeclaredIn(appDir, ceiling) {
+  const filesystemRoot = path11.parse(appDir).root;
+  let candidate = appDir;
+  while (true) {
+    if (readAppManifest(candidate)?.declaresEnvFileLoader === true) {
+      return candidate;
+    }
+    if (candidate === ceiling || candidate === filesystemRoot) {
+      return void 0;
+    }
+    candidate = path11.dirname(candidate);
+  }
+}
 function resolveCredentialLoad(inputs) {
   if (inputs.variableName === void 0) {
     return { kind: "no-key" };
@@ -91428,8 +91477,12 @@ function resolveCredentialLoad(inputs) {
     return { apps: apps2, kind: "ambiguous" };
   }
   const appDir = apps2[0];
-  if (readAppManifest(appDir)?.declaresEnvFileLoader === true) {
-    return { appDir, kind: "loader-declared" };
+  const declaredIn = envFileLoaderDeclaredIn(
+    appDir,
+    canonicalizeDir(inputs.ceiling)
+  );
+  if (declaredIn !== void 0) {
+    return { appDir, declaredIn, kind: "loader-declared" };
   }
   if (inputs.source === void 0) {
     return { appDir, kind: "process-environment" };
@@ -91821,8 +91874,10 @@ __export(telemetry_exports, {
   cliLogTelemetryLogger: () => cliLogTelemetryLogger,
   currentAuthIdentity: () => currentAuthIdentity,
   currentCliStateProperties: () => currentCliStateProperties,
+  currentOnboardingCodingAgent: () => currentOnboardingCodingAgent,
   currentOnboardingRunProperties: () => currentOnboardingRunProperties,
   currentProjectIdentity: () => currentProjectIdentity,
+  describeSubmissionError: () => describeSubmissionError,
   exitWithFlush: () => exitWithFlush,
   flushTelemetry: () => flushTelemetry,
   getCliConsentProvider: () => getCliConsentProvider,
@@ -91831,6 +91886,7 @@ __export(telemetry_exports, {
   hasStandaloneTelemetryIdentityConsent: () => hasStandaloneTelemetryIdentityConsent,
   linkConsentSubjectToUser: () => linkConsentSubjectToUser,
   recordTelemetryEvent: () => recordTelemetryEvent,
+  resolveReturnedOutcome: () => resolveReturnedOutcome,
   submitTelemetryEvent: () => submitTelemetryEvent,
   withTelemetry: () => withTelemetry
 });
@@ -91906,6 +91962,9 @@ function currentOnboardingRunProperties() {
   });
   return runId === void 0 ? {} : { onboarding_run_id: runId };
 }
+function currentOnboardingCodingAgent() {
+  return readCodingAgent({ cwd: process.cwd(), store: configStore });
+}
 function currentAuthIdentity() {
   return resolveAuthIdentityProperties({
     readStoredAuth: () => authStore.get()
@@ -91956,8 +92015,21 @@ async function submitTelemetryEvent(event) {
     noticeShown: hasShownTelemetryNotice(configStore)
   });
   if (!gate.send)
-    return false;
-  return await getTelemetry().submitEvent(withProjectIdentity(event));
+    return { status: "declined" };
+  try {
+    const accepted = await getTelemetry().submitEvent(
+      withProjectIdentity(event)
+    );
+    return accepted ? { status: "sent" } : { status: "failed", detail: "the transport did not accept the event" };
+  } catch (error98) {
+    return { status: "failed", detail: describeSubmissionError(error98) };
+  }
+}
+function describeSubmissionError(error98) {
+  if (error98 instanceof Error && error98.message !== "")
+    return error98.message;
+  const described = String(error98);
+  return described === "" ? "the telemetry transport threw" : described;
 }
 async function flushTelemetry(timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) {
   if (!instance)
@@ -91968,6 +92040,17 @@ async function exitWithFlush(code) {
   await flushTelemetry();
   process.exit(code);
 }
+function resolveReturnedOutcome(input) {
+  if (input.declaredFailure !== null) {
+    return {
+      outcome: "failed",
+      ...input.declaredFailure.errorCode === void 0 ? {} : { errorCode: input.declaredFailure.errorCode }
+    };
+  }
+  const { exitCode } = input;
+  const failedByExit = exitCode !== void 0 && exitCode !== 0 && exitCode !== "0";
+  return failedByExit ? { outcome: "failed" } : { outcome: "succeeded" };
+}
 async function withTelemetry(base, fn) {
   const buildInfo = getBuildInfo();
   const provider = getConsentProvider();
@@ -91988,9 +92071,13 @@ async function withTelemetry(base, fn) {
   }
   const startedAt = Date.now();
   let extra = {};
+  let declaredFailure = null;
   const ctx = {
     setProperties(next) {
       extra = { ...extra, ...next };
+    },
+    reportFailure(input) {
+      declaredFailure = input ?? {};
     }
   };
   recordTelemetryEvent({
@@ -92003,14 +92090,19 @@ async function withTelemetry(base, fn) {
   });
   try {
     const result = await fn(ctx);
+    const verdict = resolveReturnedOutcome({
+      declaredFailure,
+      exitCode: process.exitCode
+    });
     recordTelemetryEvent({
       properties: {
         ...base,
         ...currentCliStateProperties(base.command),
         ...currentOnboardingRunProperties(),
         ...extra,
-        outcome: "succeeded",
-        duration_ms: Date.now() - startedAt
+        outcome: verdict.outcome,
+        duration_ms: Date.now() - startedAt,
+        ...verdict.errorCode === void 0 ? {} : { error_code: verdict.errorCode }
       }
     });
     return result;
@@ -93755,6 +93847,9 @@ async function login(options = {}) {
     if (options.authHandoff) {
       loginParams.set("source", options.authHandoff.source);
       loginParams.set("mode", options.authHandoff.mode);
+      if (options.authHandoff.agent !== void 0) {
+        loginParams.set("agent", options.authHandoff.agent);
+      }
     }
     const loginUrl = `${getOpsFrontendUrl()}/cli-auth?${loginParams.toString()}`;
     diagnostics.logPhase("login.browser-url-prepared", {
@@ -95890,6 +95985,27 @@ var init_project_list = __esm({
 });
 
 // apps/cli/src/services/hosted-project-name.ts
+function suggestFreeProjectName(raw2, existing) {
+  const name = raw2.trim();
+  const taken = new Set(
+    existing.map((project) => project.name.trim().toLowerCase())
+  );
+  if (!taken.has(name.toLowerCase())) {
+    return name;
+  }
+  const stripped = name.replace(NUMERIC_SUFFIX, "");
+  const base = stripped === "" ? name : stripped;
+  let candidate = base;
+  for (let counter = 2; counter < SUGGESTION_ATTEMPTS + 2; counter += 1) {
+    const suffix = `-${String(counter)}`;
+    const room = MAX_PROJECT_NAME_LENGTH - suffix.length;
+    candidate = `${base.slice(0, room)}${suffix}`;
+    if (!taken.has(candidate.toLowerCase())) {
+      return candidate;
+    }
+  }
+  return candidate;
+}
 function validateProjectName(raw2, existing) {
   const name = raw2.trim();
   if (name === "") {
@@ -95914,16 +96030,19 @@ function validateProjectName(raw2, existing) {
       ok: false,
       reason: "duplicate",
       message: `You already have a project named "${duplicate.name}".`,
-      duplicate
+      duplicate,
+      suggestion: suggestFreeProjectName(name, existing)
     };
   }
   return { ok: true, name };
 }
-var MAX_PROJECT_NAME_LENGTH;
+var MAX_PROJECT_NAME_LENGTH, NUMERIC_SUFFIX, SUGGESTION_ATTEMPTS;
 var init_hosted_project_name = __esm({
   "apps/cli/src/services/hosted-project-name.ts"() {
     "use strict";
     MAX_PROJECT_NAME_LENGTH = 100;
+    NUMERIC_SUFFIX = /-\d+$/;
+    SUGGESTION_ATTEMPTS = 1e3;
   }
 });
 
@@ -95953,6 +96072,12 @@ function defer() {
 function ProjectExplainer({ dim = false }) {
   return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Text, { dimColor: dim, children: "An Intelligence project is where this app's threads, messages, and analytics are stored." });
 }
+function describeNameRefusal(validation) {
+  if (validation.suggestion === void 0) {
+    return validation.message;
+  }
+  return `${validation.message} "${validation.suggestion}" is free \u2014 press Enter to use it, type a different name, or cancel (Esc) and select the existing one from the list.`;
+}
 function HostedProjectSelect({
   apiClient,
   onResolved,
@@ -95967,6 +96092,7 @@ function HostedProjectSelect({
   const nameDirtyRef = (0, import_react37.useRef)(false);
   const [nameDirty, setNameDirty] = (0, import_react37.useState)(false);
   const [nameError, setNameError] = (0, import_react37.useState)("");
+  const offeredNameRef = (0, import_react37.useRef)(null);
   const pickerIndexRef = (0, import_react37.useRef)(0);
   const [pickerIndex, setPickerIndex] = (0, import_react37.useState)(0);
   const choiceRef = (0, import_react37.useRef)(null);
@@ -95998,6 +96124,8 @@ function HostedProjectSelect({
         setNameDisplay(defaultName);
         nameDirtyRef.current = false;
         setNameDirty(false);
+        offeredNameRef.current = null;
+        setNameError("");
         setView({ kind: "name" });
         return deferred.promise;
       }
@@ -96081,22 +96209,30 @@ function HostedProjectSelect({
           nameDirtyRef.current = true;
           setNameDirty(true);
         }
+        const offered = offeredNameRef.current;
+        if (offered !== null && textBeforeNewline === "") {
+          offeredNameRef.current = null;
+          setNameError("");
+          nameRef.current?.resolve(offered);
+          return;
+        }
         const validation = validateProjectName(
           nameBufferRef.current,
           projectsRef.current
         );
         if (!validation.ok) {
-          setNameError(
-            validation.reason === "duplicate" ? `${validation.message} Choose a different name, or cancel (Esc) and select it from the list.` : validation.message
-          );
+          offeredNameRef.current = validation.suggestion ?? null;
+          setNameError(describeNameRefusal(validation));
           telemetry?.onCreateNameRejected?.(validation.reason);
           return;
         }
+        offeredNameRef.current = null;
         setNameError("");
         nameRef.current?.resolve(validation.name);
         return;
       }
       if (key.backspace || key.delete) {
+        offeredNameRef.current = null;
         const updated = nameDirtyRef.current ? nameBufferRef.current.slice(0, -1) : "";
         nameDirtyRef.current = true;
         setNameDirty(true);
@@ -96105,6 +96241,7 @@ function HostedProjectSelect({
         return;
       }
       if (input && !key.ctrl && !key.meta) {
+        offeredNameRef.current = null;
         const base = nameDirtyRef.current ? nameBufferRef.current : "";
         nameDirtyRef.current = true;
         setNameDirty(true);
@@ -96645,7 +96782,8 @@ function createFlagPrompts(request) {
       kind: "name-rejected",
       reason: validation.reason,
       message: validation.message,
-      ...validation.duplicate ? { duplicateSlug: validation.duplicate.slug } : {}
+      ...validation.duplicate ? { duplicateSlug: validation.duplicate.slug } : {},
+      ...validation.suggestion === void 0 ? {} : { suggestedName: validation.suggestion }
     };
     return null;
   }
@@ -96688,7 +96826,8 @@ function createFlagPrompts(request) {
 }
 function formatFlagRefusal(refusal, command2 = "project select") {
   if (refusal.kind === "name-rejected") {
-    const remedy = refusal.duplicateSlug === void 0 ? "Pass a different --create name." : `Pass a different --create name, or select it with \`copilotkit ${command2} --project ${refusal.duplicateSlug}\`.`;
+    const free = refusal.suggestedName === void 0 ? "Pass a different --create name" : `\`--create "${refusal.suggestedName}"\` is free`;
+    const remedy = refusal.duplicateSlug === void 0 ? `${free}.` : `${free}, or select the existing project with \`copilotkit ${command2} --project ${refusal.duplicateSlug}\`.`;
     return `${refusal.message} ${remedy}
 `;
   }
@@ -96821,9 +96960,19 @@ async function driveFlagSelect(apiClient, request) {
       return withoutSelection({ kind: "canceled" });
     }
     process.stderr.write(formatFlagRefusal(recorded));
-    return withoutSelection(
-      recorded.kind === "not-found" ? { kind: "not-found", requested: recorded.requested } : { kind: "name-rejected", message: recorded.message }
-    );
+    if (recorded.kind === "not-found") {
+      return withoutSelection({
+        kind: "not-found",
+        requested: recorded.requested
+      });
+    }
+    return withoutSelection({
+      kind: "name-rejected",
+      // The refused name and the free one, in the message the payload carries.
+      // A caller reading only `error` still learns which name to retry with.
+      message: recorded.suggestedName === void 0 ? recorded.message : `${recorded.message} "${recorded.suggestedName}" is free.`,
+      ...recorded.suggestedName === void 0 ? {} : { suggestedName: recorded.suggestedName }
+    });
   }
   return await completeSelection(apiClient, result);
 }
@@ -96906,8 +97055,13 @@ async function runProjectSelectJson(options = {}) {
     throw exitError;
   }
   const error98 = exitError ?? new Error("Project selection did not complete.");
+  const suggestedName = outcome.kind === "name-rejected" ? outcome.suggestedName : void 0;
   process.stdout.write(
-    `${JSON.stringify({ error: error98.message, type: "failed" })}
+    `${JSON.stringify({
+      error: error98.message,
+      ...suggestedName === void 0 ? {} : { suggested_name: suggestedName },
+      type: "failed"
+    })}
 `
   );
   throw error98;
@@ -99860,12 +100014,50 @@ var init_learning = __esm({
 });
 
 // libs/app-api-contracts/src/threads.ts
-var threadIdSchema;
+var threadIdSchema, appUserAliasSchema, collapseAppUserAliases, refuseInternalAppUserForms, threadAppUserSchema, threadReadQuerySchema;
 var init_threads = __esm({
   "libs/app-api-contracts/src/threads.ts"() {
     "use strict";
     init_zod();
     threadIdSchema = external_exports.string().uuid();
+    appUserAliasSchema = external_exports.object({
+      endUserId: external_exports.string().trim().min(1).optional(),
+      end_user_id: external_exports.string().trim().min(1).optional(),
+      userId: external_exports.string().trim().min(1).optional(),
+      createdById: external_exports.string().trim().min(1).optional(),
+      created_by_id: external_exports.string().trim().min(1).optional(),
+      appUserId: external_exports.string().trim().min(1).optional(),
+      app_user_id: external_exports.string().trim().min(1).optional()
+    });
+    collapseAppUserAliases = (data) => ({
+      endUserId: data.endUserId ?? data.end_user_id ?? data.userId,
+      createdById: data.createdById ?? data.created_by_id,
+      appUserId: data.appUserId ?? data.app_user_id
+    });
+    refuseInternalAppUserForms = (data, ctx) => {
+      if (data.createdById) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "createdById is internal; pass bare endUserId instead."
+        });
+      }
+      if (data.appUserId) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "appUserId is not accepted; pass endUserId instead."
+        });
+      }
+    };
+    threadAppUserSchema = appUserAliasSchema.transform(collapseAppUserAliases).superRefine((data, ctx) => {
+      if (!data.endUserId) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "endUserId is required."
+        });
+      }
+      refuseInternalAppUserForms(data, ctx);
+    }).transform((data) => ({ endUserId: data.endUserId }));
+    threadReadQuerySchema = appUserAliasSchema.transform(collapseAppUserAliases).superRefine(refuseInternalAppUserForms).transform((data) => ({ endUserId: data.endUserId }));
   }
 });
 
@@ -100096,7 +100288,7 @@ async function loadLearningCommandContext() {
     productCredential: auth2.productCredential,
     productOrganizationId: auth2.clerkOrgId
   });
-  return { client: client2, projectId: project.projectId };
+  return { client: client2, projectId: project.projectId, projectSlug: project.projectSlug };
 }
 var init_learning_command_context = __esm({
   "apps/cli/src/services/learning-command-context.ts"() {
@@ -100435,6 +100627,21 @@ async function runLearningInsightsCommand(command2, dependencies) {
       command2.candidateId,
       command2.action
     );
+    if (command2.yes) {
+      dependencies.telemetry.onReviewViewed({
+        action: command2.action,
+        durationMs: Date.now() - startedAt,
+        operation: review.operation,
+        reviewMode
+      });
+      dependencies.telemetry.onReviewDecided({
+        action: command2.action,
+        decision: "confirmed",
+        durationMs: 0,
+        operation: review.operation,
+        reviewMode
+      });
+    }
     dependencies.telemetry.setProperties({
       candidate_operation: review.operation,
       review_mode: reviewMode,
@@ -100581,11 +100788,27 @@ var init_learning_containers_api = __esm({
   }
 });
 
+// apps/cli/src/services/learning-default-container.ts
+function defaultContainerIdFromProjectSlug(projectSlug) {
+  const reshaped = projectSlug.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+  if (reshaped === "")
+    return void 0;
+  const bounded = reshaped.slice(0, MAX_ID_LENGTH).replace(/-+$/u, "");
+  return bounded === "" ? void 0 : bounded;
+}
+var MAX_ID_LENGTH;
+var init_learning_default_container = __esm({
+  "apps/cli/src/services/learning-default-container.ts"() {
+    "use strict";
+    MAX_ID_LENGTH = 64;
+  }
+});
+
 // apps/cli/src/ui/learning-container-prompts.tsx
 function LearningContainerCreatePrompt(props) {
   const firstStep = props.initial.id === void 0 ? "id" : props.initial.name === void 0 ? "name" : "prompt";
   const [step, setStep] = (0, import_react43.useState)(firstStep);
-  const [id, setId] = (0, import_react43.useState)(props.initial.id ?? "");
+  const [id, setId] = (0, import_react43.useState)(props.initial.id ?? props.initial.proposedId ?? "");
   const [name, setName] = (0, import_react43.useState)(props.initial.name ?? "");
   const [promptContext, setPromptContext] = (0, import_react43.useState)(
     props.initial.promptContext ?? ""
@@ -100757,6 +100980,66 @@ function LearningContainerDeletePrompt(props) {
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { children: "(y/N) " })
   ] });
 }
+function LearningContainerSelectPrompt(props) {
+  const createIndex = props.containers.length;
+  const moreIndex = props.hasMore ? createIndex + 1 : -1;
+  const itemCount = createIndex + (props.hasMore ? 2 : 1);
+  const [index2, setIndex] = (0, import_react43.useState)(0);
+  const indexRef = (0, import_react43.useRef)(0);
+  const finished2 = (0, import_react43.useRef)(false);
+  const move = (delta) => {
+    const next = (indexRef.current + delta + itemCount) % itemCount;
+    indexRef.current = next;
+    setIndex(next);
+  };
+  const finish = (selection) => {
+    if (finished2.current)
+      return;
+    finished2.current = true;
+    props.onComplete(selection);
+  };
+  use_input_default((_input, key) => {
+    if (key.downArrow) {
+      move(1);
+      return;
+    }
+    if (key.upArrow) {
+      move(-1);
+      return;
+    }
+    if (key.escape) {
+      if (finished2.current)
+        return;
+      finished2.current = true;
+      props.onCancel();
+      return;
+    }
+    if (!key.return)
+      return;
+    const position = indexRef.current;
+    if (position === moreIndex) {
+      finish({ kind: "more" });
+      return;
+    }
+    if (position === createIndex) {
+      finish({ kind: "create" });
+      return;
+    }
+    const container = props.containers[position];
+    if (container === void 0)
+      return;
+    finish({ containerId: container.id, kind: "chosen" });
+  });
+  const marker = (position) => position === index2 ? ">" : " ";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Box_default, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { bold: true, children: "Select a Learning Container" }),
+    props.containers.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { dimColor: true, children: "This project has none yet." }) : null,
+    props.containers.map((container, position) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { children: `${marker(position)} ${container.id}  ${container.name}` }, container.id)),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { children: `${marker(createIndex)} Create a new container` }),
+    props.hasMore ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { children: `${marker(moreIndex)} Show more` }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { dimColor: true, children: "Up and down move, Enter selects, Esc cancels." })
+  ] });
+}
 var import_react43, import_jsx_runtime13;
 var init_learning_container_prompts = __esm({
   async "apps/cli/src/ui/learning-container-prompts.tsx"() {
@@ -100806,6 +101089,22 @@ async function promptUpdate(container) {
   await app.waitUntilExit();
   return result;
 }
+async function promptSelect(input) {
+  let result = null;
+  const app = render_default(
+    (0, import_react44.createElement)(LearningContainerSelectPrompt, {
+      containers: input.containers,
+      hasMore: input.hasMore,
+      onCancel: () => setTimeout(() => app.unmount(), 0),
+      onComplete: (selection) => {
+        result = selection;
+        setTimeout(() => app.unmount(), 0);
+      }
+    })
+  );
+  await app.waitUntilExit();
+  return result;
+}
 async function confirmDelete(container) {
   let confirmed = false;
   const app = render_default(
@@ -100823,12 +101122,13 @@ async function confirmDelete(container) {
 function createLearningContainersCommandDependencies() {
   return {
     interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
-    interaction: { confirmDelete, promptCreate, promptUpdate },
+    interaction: { confirmDelete, promptCreate, promptSelect, promptUpdate },
     loadContext: async () => {
-      const { client: client2, projectId } = await loadLearningCommandContext();
+      const { client: client2, projectId, projectSlug } = await loadLearningCommandContext();
       return {
         api: createLearningContainersApi(client2),
-        projectId
+        projectId,
+        projectSlug
       };
     },
     writeStdout: (text2) => {
@@ -100973,6 +101273,59 @@ Created: ${container.createdAt}
 Updated: ${container.updatedAt}
 `;
 }
+async function selectLearningContainer(dependencies, projectId) {
+  const { api, projectSlug } = await dependencies.loadContext();
+  const proposedId = projectSlug === void 0 ? void 0 : defaultContainerIdFromProjectSlug(projectSlug);
+  const seen = [];
+  let cursor;
+  let exhausted = false;
+  let pagesRead = 0;
+  const reportSurvey = (selection) => {
+    dependencies.telemetry?.setProperties({
+      container_count: seen.length,
+      container_more_pages: !exhausted,
+      container_pages_read: pagesRead,
+      ...selection === void 0 ? {} : { container_selection: selection }
+    });
+  };
+  for (; ; ) {
+    if (!exhausted) {
+      const page = await api.list(projectId, cursor);
+      pagesRead += 1;
+      seen.push(...page.containers);
+      cursor = page.nextCursor ?? void 0;
+      exhausted = cursor === void 0;
+    }
+    const answer = await dependencies.interaction.promptSelect({
+      containers: [...seen],
+      hasMore: !exhausted
+    });
+    if (answer === null) {
+      reportSurvey();
+      dependencies.writeStdout("Canceled.\n");
+      throw userAbortedError2();
+    }
+    if (answer.kind === "more")
+      continue;
+    if (answer.kind === "create") {
+      reportSurvey("created");
+      const input = await dependencies.interaction.promptCreate(
+        proposedId === void 0 ? {} : { proposedId }
+      );
+      if (input === null) {
+        dependencies.writeStdout("Canceled.\n");
+        throw userAbortedError2();
+      }
+      return api.create(projectId, input);
+    }
+    reportSurvey("chosen");
+    const chosen = seen.find((held) => held.id === answer.containerId);
+    if (chosen === void 0) {
+      throw containerNotFoundError(answer.containerId);
+    }
+    return chosen;
+  }
+}
 async function runLearningContainersCommand(command2, dependencies) {
   try {
     validateLearningContainersCommandFlags(command2);
@@ -100991,9 +101344,19 @@ async function runLearningContainersCommand(command2, dependencies) {
         "Learning Container delete needs --yes when confirmation is unavailable."
       );
     }
+    if (command2.action === "select" && (command2.json || !dependencies.interactive)) {
+      throw nonInteractiveError(
+        "Learning Container select needs a terminal. Read them with `learning containers list --json` and make one with `learning containers create --id <id> --name <name>`."
+      );
+    }
     const { api, projectId } = await dependencies.loadContext();
     if (command2.action === "list") {
       const page = await api.list(projectId, command2.cursor);
+      dependencies.telemetry?.setProperties({
+        container_count: page.containers.length,
+        container_more_pages: page.nextCursor !== null,
+        container_pages_read: 1
+      });
       if (command2.json) {
         writeJson2(dependencies, {
           command: "learning containers list",
@@ -101024,6 +101387,11 @@ async function runLearningContainersCommand(command2, dependencies) {
       }
       return;
     }
+    if (command2.action === "select") {
+      const container2 = await selectLearningContainer(dependencies, projectId);
+      dependencies.writeStdout(renderLearningContainer(container2));
+      return;
+    }
     if (command2.action === "create") {
       let input;
       if (command2.id !== void 0 && command2.name !== void 0) {
@@ -101148,6 +101516,7 @@ var init_learning_containers = __esm({
     init_src6();
     init_learning_containers_api();
     init_learning_command_context();
+    init_learning_default_container();
     await init_build2();
     import_react44 = __toESM(require_react(), 1);
     await init_learning_container_prompts();
@@ -101548,7 +101917,7 @@ function apiKeyPresentCheck(variableName, source, envSearch) {
     title
   };
 }
-function apiKeyLoadableCheck(facts) {
+function apiKeyLoadableCheck(facts, runtime) {
   const title = "The app can load the project API key";
   const id = "api_key_loadable_by_app";
   switch (facts.kind) {
@@ -101575,7 +101944,7 @@ function apiKeyLoadableCheck(facts) {
       };
     case "loader-declared":
       return {
-        detail: `A script in ${facts.appDir} names an env file itself, so which file that app loads is decided there rather than by its framework's default. This check does not read it.`,
+        detail: facts.declaredIn === facts.appDir ? `A script in ${facts.appDir} names an env file itself, so which file that app loads is decided there rather than by its framework's default. This check does not read it.` : `A script in ${facts.declaredIn} names an env file itself and starts the app in ${facts.appDir}, so which file that app loads is decided there rather than by its framework's default. This check does not read it.`,
         id,
         status: "undetermined",
         title
@@ -101594,13 +101963,24 @@ function apiKeyLoadableCheck(facts) {
         status: "pass",
         title
       };
-    case "not-loadable":
+    case "not-loadable": {
+      const located = `The key is in ${facts.foundIn}, which this command found by searching upward. The app in ${facts.appDir} loads env files from its own directory only, and nothing there sets ${eitherKeyName()}.`;
+      const remedy = `Write it to ${facts.expectedFile}, or re-run \`copilotkit project select\` from ${facts.appDir}.`;
+      if (runtime.kind === "ok" && reportsIntelligenceClient(runtime.info)) {
+        return {
+          detail: `${located} A runtime answered and reports an Intelligence entitlement, so some process did load a key \u2014 from a mechanism this check does not read, or from a different process than the app in ${facts.appDir}. Which it was is not decidable from here. If the runtime you probed is not that app: ${remedy}`,
+          id,
+          status: "undetermined",
+          title
+        };
+      }
       return {
-        detail: `The key is in ${facts.foundIn}, which this command found by searching upward. The app in ${facts.appDir} loads env files from its own directory only, and nothing there sets ${eitherKeyName()}, so the running application never sees it. Write it to ${facts.expectedFile}, or re-run \`copilotkit project select\` from ${facts.appDir}.`,
+        detail: `${located} So the running application never sees it. ${remedy}`,
         id,
         status: "fail",
         title
       };
+    }
   }
 }
 function apiKeyAuthenticatesCheck(probe) {
@@ -101758,12 +102138,59 @@ function intelligenceConsumedCheck(credential, runtime) {
     };
   }
   return {
-    detail: `The runtime holds an Intelligence client and ${describeIntelligenceEntitlement(runtime.info)}, so the key is being used.`,
+    detail: `The runtime holds an Intelligence client and ${describeIntelligenceEntitlement(runtime.info)}. That is a declaration, not proof of a successful call \u2014 see the deployment check below for whether it is pointed at the host this key belongs to.`,
     id: "intelligence_consumed",
     status: "pass",
     title
   };
 }
+function deploymentHost(url4) {
+  let hostname5;
+  try {
+    hostname5 = new URL(url4).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+  return LOOPBACK_HOSTNAMES.has(hostname5) ? "localhost" : hostname5;
+}
+function intelligenceHostAgreementChecks(input) {
+  const { credential, intelligenceTarget, runtime } = input;
+  if (runtime.kind !== "ok" || credential.kind !== "ok")
+    return [];
+  if (!reportsIntelligenceClient(runtime.info))
+    return [];
+  const reportedGateway = runtime.info.intelligenceWsUrl;
+  if (reportedGateway === void 0)
+    return [];
+  const observed = deploymentHost(reportedGateway);
+  const verified = deploymentHost(intelligenceTarget.verifiedUrl);
+  if (observed === void 0 || verified === void 0)
+    return [];
+  const accepted = new Set(
+    [verified, ...intelligenceTarget.pairedGatewayUrls.map(deploymentHost)].filter(
+      (host) => host !== void 0
+    )
+  );
+  if (accepted.has(observed)) {
+    return [
+      {
+        detail: `The runtime reports its Intelligence gateway on ${observed}, which belongs to the deployment this command proved the key against (${verified}).`,
+        id: "intelligence_host_agreement",
+        status: "pass",
+        title: HOST_AGREEMENT_TITLE
+      }
+    ];
+  }
+  const unnamed = intelligenceTarget.source === "cli-default" ? ` This project names no INTELLIGENCE_API_URL, so ${verified} is only this CLI's own default and the runtime fell back to its own.` : "";
+  return [
+    {
+      detail: `The key was proven against ${verified}, but the runtime reports its Intelligence gateway on ${observed} \u2014 a different deployment.${unnamed} Every check above tested a host the runtime never calls, so a valid key still gets 401 AUTH_UNAUTHENTICATED on every request. Set INTELLIGENCE_API_URL=${intelligenceTarget.verifiedUrl} in the env file the app loads, and INTELLIGENCE_GATEWAY_WS_URL to that deployment's gateway.`,
+      id: "intelligence_host_agreement",
+      status: "fail",
+      title: HOST_AGREEMENT_TITLE
+    }
+  ];
+}
 function ossRuntimeModeCheck(runtime) {
   const title = "The runtime uses the expected OSS mode";
   if (runtime.kind !== "ok") {
@@ -101799,7 +102226,11 @@ function intelligenceThreadRoutesCheck(runtime) {
       title
     };
   }
-  const { intelligenceWsUrl, threadMutationsEnabled } = runtime.info;
+  const {
+    intelligenceWsUrl,
+    singleRouteResourceOperations,
+    threadMutationsEnabled
+  } = runtime.info;
   if (!reportsIntelligenceClient(runtime.info)) {
     return {
       detail: "Not attempted: the runtime reports no Intelligence entitlement, so it has no Intelligence routes to serve. The check above names that.",
@@ -101808,6 +102239,14 @@ function intelligenceThreadRoutesCheck(runtime) {
       title
     };
   }
+  if (runtime.transport === "single-route" && singleRouteResourceOperations === void 0) {
+    return {
+      detail: "The runtime answers a single-route envelope and reports nothing about what that mount serves. Its top-level `threadEndpoints` describes the `info` call that carried the answer, not the mount, so it cannot be read either way. Upgrade @copilotkit/runtime to 1.70.2 or later: from there a single-route mount serves `threads/*` and `memories/*` over its `resource/request` method and says so.",
+      id: "intelligence_thread_routes",
+      status: "undetermined",
+      title
+    };
+  }
   if (threadMutationsEnabled === void 0) {
     return {
       detail: "The runtime reports no thread-endpoint state. Runtimes that predate the `threadEndpoints` field in /info omit it, so this could not be read either way. Upgrade @copilotkit/runtime to have it reported.",
@@ -101818,14 +102257,14 @@ function intelligenceThreadRoutesCheck(runtime) {
   }
   if (!threadMutationsEnabled) {
     return {
-      detail: runtime.transport === "single-route" ? 'The runtime reports a license but serves no thread or memory routes, so saved Threads cannot be listed or written from the browser. That is what `mode: "single-route"` does: its envelope carries no threads/* or memories/* method. Remove `mode: "single-route"` and mount the handler at a catch-all route \u2014 https://docs.copilotkit.ai/backend/runtime-endpoints#enable-rich-threads-routes' : intelligenceWsUrl === void 0 ? "The runtime reports a license but serves no thread routes and no gateway URL, which is an Intelligence runtime built without `identifyUser`. That gates the whole web surface. Pass `identifyUser` where the runtime is constructed." : "The runtime reports a license and a gateway URL but still serves no thread routes, so saved Threads cannot be listed or written from the browser \u2014 https://docs.copilotkit.ai/backend/runtime-endpoints#enable-rich-threads-routes",
+      detail: intelligenceWsUrl === void 0 ? "The runtime reports a license but serves no thread routes and no gateway URL, which is an Intelligence runtime built without `identifyUser`. That gates the whole web surface. Pass `identifyUser` where the runtime is constructed." : "The runtime reports a license and a gateway URL but still serves no thread routes, so saved Threads cannot be listed or written from the browser \u2014 https://docs.copilotkit.ai/backend/runtime-endpoints#enable-rich-threads-routes",
       id: "intelligence_thread_routes",
       status: "fail",
       title
     };
   }
   return {
-    detail: "The runtime serves the thread routes, so saved Threads load.",
+    detail: runtime.transport === "single-route" ? "The runtime serves the thread routes over its single-route envelope, as the `resource/request` method rather than as REST paths, so saved Threads load." : "The runtime serves the thread routes, so saved Threads load.",
     id: "intelligence_thread_routes",
     status: "pass",
     title
@@ -102014,11 +102453,12 @@ function runVerifyChecks(input, expectedRuntime = "intelligence") {
       input.apiKeySource,
       input.envSearch
     ),
-    apiKeyLoadableCheck(input.credentialLoad),
+    apiKeyLoadableCheck(input.credentialLoad, input.runtime),
     apiKeyAuthenticatesCheck(input.credential),
     runtimeReachableCheck(input.runtime, input.runtimeUrl),
     runtimeAgentsCheck(input.runtime, input.runtimeUrl),
     intelligenceConsumedCheck(input.credential, input.runtime),
+    ...intelligenceHostAgreementChecks(input),
     intelligenceThreadRoutesCheck(input.runtime),
     ...frontendAssetChecks(input),
     ...corsChecks(input),
@@ -102032,7 +102472,7 @@ function runVerifyChecks(input, expectedRuntime = "intelligence") {
     ok: checks.every((check4) => check4.status === "pass")
   };
 }
-var API_KEY_VARIABLE_NAMES, VERSIONS_CHECK_TITLE, CORS_CHECK_TITLE;
+var API_KEY_VARIABLE_NAMES, LOOPBACK_HOSTNAMES, HOST_AGREEMENT_TITLE, VERSIONS_CHECK_TITLE, CORS_CHECK_TITLE;
 var init_verify_checks = __esm({
   "apps/cli/src/services/verify-checks.ts"() {
     "use strict";
@@ -102043,6 +102483,14 @@ var init_verify_checks = __esm({
       "COPILOTKIT_API_KEY",
       "INTELLIGENCE_API_KEY"
     ];
+    LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+      "localhost",
+      "127.0.0.1",
+      "[::1]",
+      "::1",
+      "0.0.0.0"
+    ]);
+    HOST_AGREEMENT_TITLE = "The runtime and this command address the same Intelligence deployment";
     VERSIONS_CHECK_TITLE = "The installed packages match the runtime";
     CORS_CHECK_TITLE = "The runtime accepts the frontend origin";
   }
@@ -377720,6 +378168,9 @@ var init_telemetry2 = __esm({
 });
 
 // apps/cli/src/services/round-trip-checks.ts
+function describeReadVia(readVia) {
+  return readVia === "app-mount" ? "Read back through the app, so the answer belongs to the caller the app identified." : "Read back from app-api, because this mount serves no thread route: the run and its answer are proved, the end user it belonged to is not.";
+}
 function runRoundTripCheck(agentId, probe, runtimeUrlSource) {
   const check4 = decideRoundTrip(agentId, probe);
   if (runtimeUrlSource !== "default" || probe.kind === "unreachable") {
@@ -377731,10 +378182,11 @@ function decideRoundTrip(agentId, probe) {
   if (probe.kind === "answered") {
     const toolNote = probe.toolCallNames.length > 0 ? ` It called ${probe.toolCallNames.join(", ")}.` : "";
     return {
-      detail: `Agent "${agentId}" answered with ${String(probe.text.length)} characters, recorded on thread ${probe.threadId}.${toolNote}`,
+      detail: `Agent "${agentId}" answered with ${String(probe.text.length)} characters, recorded on thread ${probe.threadId}.${toolNote} ${describeReadVia(probe.readVia)}`,
       evidence: {
         agentId,
         answerCharacters: probe.text.length,
+        readVia: probe.readVia,
         threadId: probe.threadId,
         toolCallNames: probe.toolCallNames
       },
@@ -377768,7 +378220,7 @@ function decideRoundTrip(agentId, probe) {
     };
   }
   return {
-    detail: `The run started but nothing from agent "${agentId}" was ever recorded on thread ${probe.threadId}. The agent accepted the request and produced no answer \u2014 check its own logs for a failure after start-up.`,
+    detail: `The run started but nothing from agent "${agentId}" was ever recorded on thread ${probe.threadId}. The agent accepted the request and produced no answer \u2014 check its own logs for a failure after start-up. ${describeReadVia(probe.readVia)}`,
     id: "agent_answers",
     status: "fail",
     title: TITLE
@@ -377813,13 +378265,26 @@ async function pollForAnswer(params, threadId) {
   const deadline = now() + (params.timeoutMs ?? DEFAULT_ROUND_TRIP_TIMEOUT_MS);
   for (; ; ) {
     const attempt = await readAnswer(params, threadId);
-    if (attempt.kind !== "no-answer")
-      return attempt;
-    if (now() >= deadline)
-      return attempt;
+    if (attempt.kind === "read-refused") {
+      if (!isRetryableRead(attempt.status))
+        return refusedRead(attempt);
+      if (now() >= deadline)
+        return refusedRead(attempt);
+    } else {
+      if (attempt.kind !== "no-answer")
+        return attempt;
+      if (now() >= deadline)
+        return attempt;
+    }
     await sleep3(POLL_INTERVAL_MS);
   }
 }
+function isRetryableRead(status) {
+  return status === 404 || status >= 500;
+}
+function refusedRead(attempt) {
+  return { kind: "unreachable", message: attempt.message };
+}
 async function startRun(params, sentThreadId) {
   const body = {
     context: [],
@@ -377836,14 +378301,14 @@ async function startRun(params, sentThreadId) {
     threadId: sentThreadId,
     tools: []
   };
-  const response = await params.fetchImpl(
-    runtimeRouteUrl(params.runtimeUrl, `agent/${params.agentId}/run`),
-    {
-      body: JSON.stringify(body),
-      headers: { "content-type": "application/json", ...params.headers },
-      method: "POST"
-    }
-  );
+  const singleRoute = params.transport === "single-route";
+  const url4 = singleRoute ? params.runtimeUrl.replace(/\/+$/u, "") : runtimeRouteUrl(params.runtimeUrl, `agent/${params.agentId}/run`);
+  const payload = singleRoute ? { body, method: "agent/run", params: { agentId: params.agentId } } : body;
+  const response = await params.fetchImpl(url4, {
+    body: JSON.stringify(payload),
+    headers: { "content-type": "application/json", ...params.headers },
+    method: "POST"
+  });
   if (!response.ok) {
     const message = await refusalMessage(response);
     return isIdentityRefusal(message) ? { kind: "user-not-identified", message } : { kind: "run-error", message };
@@ -377896,13 +378361,49 @@ async function drain(response) {
   }
 }
 async function readAnswer(params, threadId) {
-  const response = await params.fetchImpl(
-    runtimeRouteUrl(params.runtimeUrl, `threads/${threadId}/messages`),
-    params.headers === void 0 ? void 0 : { headers: params.headers }
-  );
-  const payload = await response.json();
+  const platform4 = params.transport === "single-route" ? params.platform : void 0;
+  const readVia = platform4 === void 0 ? "app-mount" : "app-api";
+  const request = platform4 === void 0 ? {
+    init: params.headers === void 0 ? void 0 : { headers: params.headers },
+    url: runtimeRouteUrl(params.runtimeUrl, `threads/${threadId}/messages`)
+  } : {
+    init: {
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${platform4.apiKey}`
+      }
+    },
+    url: `${platform4.appApiUrl.replace(/\/+$/u, "")}/api/threads/${threadId}/messages`
+  };
+  const response = await params.fetchImpl(request.url, request.init);
+  if (!response.ok) {
+    return {
+      kind: "read-refused",
+      message: `${request.url} answered ${String(response.status)}${await refusalDetail(response)}`,
+      status: response.status
+    };
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    return {
+      kind: "read-refused",
+      message: `${request.url} did not answer JSON`,
+      status: response.status
+    };
+  }
   const answer = lastAssistantAnswer(payload);
-  return answer === void 0 ? { kind: "no-answer", threadId } : { kind: "answered", threadId, ...answer };
+  return answer === void 0 ? { kind: "no-answer", readVia, threadId } : { kind: "answered", readVia, threadId, ...answer };
+}
+async function refusalDetail(response) {
+  try {
+    const body = await response.json();
+    const code = typeof body === "object" && body !== null && typeof body.error === "object" && body.error !== null && typeof body.error.code === "string" ? body.error.code : void 0;
+    return code === void 0 ? "" : ` (${code})`;
+  } catch {
+    return "";
+  }
 }
 function lastAssistantAnswer(payload) {
   const messages = typeof payload === "object" && payload !== null && "messages" in payload && Array.isArray(payload.messages) ? payload.messages : [];
@@ -377933,6 +378434,68 @@ var init_round_trip_probe = __esm({
   }
 });
 
+// apps/cli/src/services/learning-container-check.ts
+function redact(text2, apiKey) {
+  return text2.split(apiKey).join("[redacted]");
+}
+async function checkLearningContainer(params) {
+  const { apiKey } = params;
+  if (apiKey === void 0) {
+    return {
+      kind: "not-attempted",
+      message: "Not attempted: no Intelligence API key was resolved, and the thread read needs one."
+    };
+  }
+  const url4 = `${params.appApiUrl.replace(/\/+$/u, "")}/api/threads/${params.threadId}`;
+  let response;
+  try {
+    response = await params.fetchImpl(url4, {
+      headers: { accept: "application/json", authorization: `Bearer ${apiKey}` },
+      method: "GET"
+    });
+  } catch (error98) {
+    const detail = error98 instanceof Error ? error98.message : String(error98);
+    return {
+      kind: "unreachable",
+      message: `could not reach ${url4} (${redact(detail, apiKey)})`
+    };
+  }
+  if (!response.ok) {
+    return {
+      kind: "unreachable",
+      message: `${url4} answered ${String(response.status)}`
+    };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { kind: "unreachable", message: `${url4} did not answer JSON` };
+  }
+  const thread = typeof body === "object" && body !== null && typeof body.thread === "object" && body.thread !== null ? body.thread : void 0;
+  if (thread === void 0) {
+    return {
+      kind: "unreachable",
+      message: `${url4} answered 200 without a thread`
+    };
+  }
+  const actual = typeof thread["learningContainerId"] === "string" ? thread["learningContainerId"] : void 0;
+  if (actual === params.expected) {
+    return { containerId: actual, kind: "proved", threadId: params.threadId };
+  }
+  return {
+    actual,
+    expected: params.expected,
+    kind: "mismatch",
+    threadId: params.threadId
+  };
+}
+var init_learning_container_check = __esm({
+  "apps/cli/src/services/learning-container-check.ts"() {
+    "use strict";
+  }
+});
+
 // apps/cli/src/services/installed-packages.ts
 import { readFileSync as readFileSync16 } from "node:fs";
 import { dirname as dirname10, join as join21, sep } from "node:path";
@@ -378088,7 +378651,8 @@ function toRuntimeProbe(body, status, transport) {
     }
   );
   const wsUrl = parsed.data.intelligence?.wsUrl;
-  const mutations = parsed.data.threadEndpoints?.mutations;
+  const singleRoute = parsed.data.singleRoute;
+  const mutations = singleRoute === void 0 ? parsed.data.threadEndpoints?.mutations : singleRoute.threadEndpoints?.mutations;
   const info = {
     agents,
     ...parsed.data.audioFileTranscriptionEnabled === void 0 ? {} : {
@@ -378098,6 +378662,7 @@ function toRuntimeProbe(body, status, transport) {
     ...parsed.data.licenseStatus === void 0 ? {} : { licenseStatus: parsed.data.licenseStatus },
     ...parsed.data.runtimeEntitlements === void 0 ? {} : { runtimeEntitlements: parsed.data.runtimeEntitlements },
     openGenerativeUIEnabled: parsed.data.openGenerativeUIEnabled ?? false,
+    ...singleRoute?.resourceOperations === void 0 ? {} : { singleRouteResourceOperations: singleRoute.resourceOperations },
     ...mutations === void 0 ? {} : { threadMutationsEnabled: mutations },
     version: parsed.data.version
   };
@@ -378241,6 +378806,15 @@ var init_verify_probes = __esm({
       licenseStatus: external_exports.string().optional(),
       runtimeEntitlements: external_exports.object({ status: external_exports.string().optional() }).loose().optional(),
       openGenerativeUIEnabled: external_exports.boolean().optional(),
+      /**
+       * Reported only by a single-route mount, from `@copilotkit/runtime` 1.70.2
+       * onward. Its `threadEndpoints` describes the mount; the top-level one
+       * describes the `info` call that carried this payload (OSS-1166).
+       */
+      singleRoute: external_exports.object({
+        resourceOperations: external_exports.boolean().optional(),
+        threadEndpoints: external_exports.object({ mutations: external_exports.boolean().optional() }).loose().optional()
+      }).loose().optional(),
       threadEndpoints: external_exports.object({ mutations: external_exports.boolean().optional() }).loose().optional(),
       version: external_exports.string()
     });
@@ -378325,8 +378899,8 @@ function factRows(facts) {
   }
   return rows;
 }
-function renderSummary(result, roundTrip) {
-  const all = [...result.checks, ...roundTrip ? [roundTrip] : []];
+function renderSummary(result, roundTrip, extra = []) {
+  const all = [...result.checks, ...roundTrip ? [roundTrip] : [], ...extra];
   const passed = all.filter((check4) => check4.status === "pass").length;
   const failed2 = all.filter((check4) => check4.status === "fail").length;
   const unknown3 = all.filter(
@@ -378341,7 +378915,7 @@ function renderSummary(result, roundTrip) {
   }
   return parts.join(", ");
 }
-function renderVerifyReport(result, context3, roundTrip) {
+function renderVerifyReport(result, context3, roundTrip, extra = []) {
   const urlNote = `Runtime URL: ${context3.runtimeUrl} ${describeRuntimeUrlSource(context3)}`;
   const frontendNote = context3.frontendUrl.url === void 0 ? "Frontend URL: not resolved (nothing in this project named the port its frontend serves; pass --frontend-url)" : `Frontend URL: ${context3.frontendUrl.url} ${describeFrontendUrlSource(context3.frontendUrl)}`;
   const lines = [
@@ -378361,6 +378935,10 @@ function renderVerifyReport(result, context3, roundTrip) {
     );
     lines.push(`          ${roundTrip.detail}`);
   }
+  for (const check4 of extra) {
+    lines.push(`  ${STATUS_LABELS[check4.status].padEnd(7)} ${check4.title}`);
+    lines.push(`          ${check4.detail}`);
+  }
   const rows = factRows(result.facts);
   if (rows.length > 0) {
     const labelWidth = Math.max(...rows.map(([label]) => label.length));
@@ -378369,10 +378947,10 @@ function renderVerifyReport(result, context3, roundTrip) {
       lines.push(`  ${label.padEnd(labelWidth)}  ${value}`);
     }
   }
-  lines.push("", renderSummary(result, roundTrip), "");
+  lines.push("", renderSummary(result, roundTrip, extra), "");
   return lines.join("\n");
 }
-function renderVerifyJson(result, context3, roundTrip) {
+function renderVerifyJson(result, context3, roundTrip, extra = []) {
   return `${JSON.stringify(
     {
       checks: result.checks,
@@ -378380,8 +378958,9 @@ function renderVerifyJson(result, context3, roundTrip) {
       // `ok` answers "is this project proven", so a requested round trip that
       // did not pass makes it false. Omitting the round trip from the verdict
       // would let the strongest evidence in the report contradict its summary.
-      ok: result.ok && (roundTrip === void 0 || roundTrip.status === "pass"),
+      ok: result.ok && (roundTrip === void 0 || roundTrip.status === "pass") && extra.every((check4) => check4.status === "pass"),
       ...roundTrip === void 0 ? {} : { roundTrip },
+      ...extra.length === 0 ? {} : { extraChecks: extra },
       // The origin a caller opens, so it never composes one. Absent rather than
       // guessed when the project named no port (OSS-1126).
       ...context3.frontendUrl.url === void 0 ? {} : { frontendUrl: context3.frontendUrl.url },
@@ -378419,6 +378998,7 @@ function liveDependencies() {
   return {
     appApiUrl: getAppApiUrl(),
     cwd: process.cwd(),
+    hostedGatewayUrl: getHostedGatewayUrl(),
     env: process.env,
     fetchImpl: fetch,
     newId: (prefix) => `${prefix}-${randomUUID8()}`,
@@ -378459,7 +379039,9 @@ async function runVerify(options, overrides = {}) {
     projectEnvValues: projectEnv.values,
     ...options.frontendUrl === void 0 ? {} : { flagUrl: options.frontendUrl }
   });
-  const appApiUrl = (mergedEnv["INTELLIGENCE_API_URL"] ?? "").trim() || deps.appApiUrl;
+  const projectApiUrl = (mergedEnv["INTELLIGENCE_API_URL"] ?? "").trim();
+  const appApiUrl = projectApiUrl || deps.appApiUrl;
+  const pairedGatewayUrls = (projectApiUrl === "" ? [deps.hostedGatewayUrl] : [(mergedEnv["INTELLIGENCE_GATEWAY_WS_URL"] ?? "").trim()]).filter((url4) => url4 !== "");
   const corsApplies = options.frontendUrl !== void 0 && frontendUrlResolution.url !== void 0 && new URL(frontendUrlResolution.url).origin !== new URL(runtimeUrl).origin;
   const [credential, runtime, frontendAssets, cors] = await Promise.all([
     probeCredential(appApiUrl, apiKey?.key, deps.fetchImpl),
@@ -378503,6 +379085,11 @@ async function runVerify(options, overrides = {}) {
       frontendAssets,
       frontendUrl: frontendUrlResolution,
       installedPackages,
+      intelligenceTarget: {
+        pairedGatewayUrls,
+        source: projectApiUrl === "" ? "cli-default" : "project-env",
+        verifiedUrl: appApiUrl
+      },
       projectConfig,
       runtime,
       runtimeUrl: runtimeUrlResolution
@@ -378511,24 +379098,89 @@ async function runVerify(options, overrides = {}) {
   );
   const roundTrip = expectedRuntime === "oss" && (options.roundTrip !== true || options.agent === void 0) ? notAttempted(
     "Not attempted: --expect-runtime oss requires --round-trip --agent <id> so the named agent must answer before this command can pass."
-  ) : options.roundTrip === true ? await runLiveRoundTrip(options, deps, runtimeUrlResolution, runtime) : void 0;
+  ) : options.roundTrip === true ? await runLiveRoundTrip(
+    options,
+    deps,
+    runtimeUrlResolution,
+    runtime,
+    appApiUrl,
+    apiKey?.key
+  ) : void 0;
   const context3 = {
     frontendUrl: frontendUrlResolution,
     runtimeUrl,
     runtimeUrlSource: runtimeUrlResolution.source,
     ...runtimeUrlResolution.origin === void 0 ? {} : { runtimeUrlOrigin: runtimeUrlResolution.origin }
   };
+  const learningContainer = options.expectLearningContainer === void 0 ? void 0 : await runLearningContainerCheck(
+    options.expectLearningContainer,
+    deps,
+    appApiUrl,
+    apiKey?.key,
+    roundTrip
+  );
+  const extra = learningContainer === void 0 ? [] : [learningContainer];
   deps.stdout(
-    options.json ? renderVerifyJson(result, context3, roundTrip) : renderVerifyReport(result, context3, roundTrip)
+    options.json ? renderVerifyJson(result, context3, roundTrip, extra) : renderVerifyReport(result, context3, roundTrip, extra)
   );
-  if (!result.ok || roundTrip !== void 0 && roundTrip.status !== "pass") {
+  if (!result.ok || roundTrip !== void 0 && roundTrip.status !== "pass" || extra.some((check4) => check4.status !== "pass")) {
     process.exitCode = 1;
   }
 }
-async function runLiveRoundTrip(options, deps, runtimeUrl, runtime) {
-  if (runtime.kind === "ok" && runtime.transport === "single-route") {
+async function runLearningContainerCheck(expected, deps, appApiUrl, apiKey, roundTrip) {
+  const base = {
+    id: "learning_container_assigned",
+    title: LEARNING_TITLE
+  };
+  const threadId = roundTrip?.evidence?.threadId;
+  if (threadId === void 0) {
+    deps.recordLearningContainerCheck?.({ outcome: "undetermined" });
+    return {
+      ...base,
+      detail: "Not attempted: no thread was created, so there is nothing to read. The assignment is made while a run starts, so this check needs --round-trip --agent <id> to have run one.",
+      status: "undetermined"
+    };
+  }
+  const checked = await checkLearningContainer({
+    apiKey,
+    // The resolved host, not the build-time default. A project that names
+    // `INTELLIGENCE_API_URL` — a self-hosted deployment, or a test standing up
+    // a stub — is the project this check must ask about.
+    appApiUrl,
+    expected,
+    fetchImpl: deps.fetchImpl,
+    threadId
+  });
+  if (checked.kind === "proved") {
+    deps.recordLearningContainerCheck?.({ outcome: "proved" });
+    return {
+      ...base,
+      detail: `Thread ${checked.threadId} came back from app-api carrying Learning Container "${checked.containerId}". Read from the platform, so it holds whichever way the runtime is mounted.`,
+      status: "pass"
+    };
+  }
+  if (checked.kind === "mismatch") {
+    deps.recordLearningContainerCheck?.({
+      outcome: checked.actual === void 0 ? "unassigned" : "other-container"
+    });
+    return {
+      ...base,
+      detail: checked.actual === void 0 ? `Thread ${checked.threadId} carries no Learning Container, so nothing was assigned. The selector returned nothing for this run, or the runtime holds no getLearningContainerId at all. A plan entitlement or an /info flag saying otherwise is not evidence.` : `Thread ${checked.threadId} is assigned to "${checked.actual}", not "${checked.expected}". A thread cannot move between Containers after its first assignment, so start a new thread rather than repairing this one.`,
+      status: "fail"
+    };
+  }
+  deps.recordLearningContainerCheck?.({ outcome: "undetermined" });
+  return {
+    ...base,
+    detail: `Not proven: ${checked.message}`,
+    status: "undetermined"
+  };
+}
+async function runLiveRoundTrip(options, deps, runtimeUrl, runtime, appApiUrl, apiKey) {
+  const singleRoute = runtime.kind === "ok" && runtime.transport === "single-route";
+  if (singleRoute && apiKey === void 0) {
     return notAttempted(
-      'Not attempted: this runtime answers a single-route envelope, and the round trip reads its answer back from a thread route that mount does not serve. Remove `mode: "single-route"` from the handler to run it.'
+      "Not attempted: this runtime answers a single-route envelope, so its answer has to be read from the platform, and no Intelligence API key was resolved to read it with. The checks above name the credential this project is missing."
     );
   }
   const declared = runtime.kind === "ok" ? runtime.info.agents : [];
@@ -378553,6 +379205,10 @@ async function runLiveRoundTrip(options, deps, runtimeUrl, runtime) {
   const probe = await probeRoundTrip({
     agentId,
     fetchImpl: deps.fetchImpl,
+    ...singleRoute ? {
+      platform: { apiKey: apiKey ?? "", appApiUrl },
+      transport: "single-route"
+    } : {},
     newId: deps.newId,
     newThreadId: deps.newThreadId,
     runtimeUrl: runtimeUrl.url,
@@ -378570,6 +379226,7 @@ function notAttempted(detail) {
     title: "The agent answers a real request"
   };
 }
+var LEARNING_TITLE;
 var init_verify = __esm({
   "apps/cli/src/commands/verify.ts"() {
     "use strict";
@@ -378579,6 +379236,7 @@ var init_verify = __esm({
     init_project_env();
     init_round_trip_checks();
     init_round_trip_probe();
+    init_learning_container_check();
     init_verify_checks();
     init_installed_packages();
     init_verify_probes();
@@ -378586,6 +379244,7 @@ var init_verify = __esm({
     init_runtime_url();
     init_frontend_url();
     init_runtime_url();
+    LEARNING_TITLE = "The run is assigned to the Learning Container";
   }
 });
 
@@ -384520,6 +385179,7 @@ async function runLoginJson(dependencies = {
   login,
   recordEvent: recordTelemetryEvent,
   readAuthIdentity: currentAuthIdentity,
+  readCodingAgent: currentOnboardingCodingAgent,
   readOnboardingRun: currentOnboardingRunProperties
 }) {
   try {
@@ -384533,8 +385193,13 @@ async function runLoginJson(dependencies = {
       return;
     }
     let loginUrlWritten = false;
+    const codingAgent = dependencies.readCodingAgent();
     await dependencies.login({
-      authHandoff: { source: "cli", mode: "agent_onboarding" },
+      authHandoff: {
+        source: "cli",
+        mode: "agent_onboarding",
+        ...codingAgent === void 0 ? {} : { agent: codingAgent }
+      },
       openBrowser: false,
       onLoginUrl: (url4) => {
         if (loginUrlWritten) {
@@ -384994,6 +385659,8 @@ var init_onboarding_checkpoint = __esm({
       "research-returned",
       "starter-cloned",
       "plan-written",
+      "container-surveyed",
+      "container-settled",
       "build-validated",
       "journey-attempted",
       "repair-attempted"
@@ -385005,13 +385672,70 @@ var init_onboarding_checkpoint = __esm({
 // apps/cli/src/services/onboarding-protected-paths.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync24, readFileSync as readFileSync24, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync24, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
 import { isAbsolute, join as join31, relative as relative3, resolve as resolve7, sep as sep3 } from "node:path";
+function deriveProjectFiles(root2) {
+  const found = [];
+  const pending = [root2];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (directory === void 0)
+      break;
+    let entries;
+    try {
+      entries = readdirSync4(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const absolute = join31(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIPPED_DIRECTORIES3.has(entry.name))
+          pending.push(absolute);
+        continue;
+      }
+      const relativePath = toRepositoryRelative(root2, absolute);
+      if (relativePath !== void 0)
+        found.push(relativePath);
+    }
+  }
+  return found;
+}
 function isGraphOwned(relativePath) {
   return GRAPH_OWNED_SUFFIXES.some(
     (suffix) => relativePath === suffix || relativePath.endsWith(`/${suffix}`)
   );
 }
+function isEnvPath(relativePath) {
+  return relativePath === ".env" || relativePath.endsWith("/.env");
+}
+function envKeysOf(root2, relativePath) {
+  const absolute = join31(root2, relativePath);
+  try {
+    if (!existsSync24(absolute))
+      return [];
+    const values = readDotEnvValues(readFileSync24(absolute, "utf8"));
+    return Object.entries(values).map(([name, value]) => ({
+      name,
+      hasValue: value.trim() !== ""
+    }));
+  } catch {
+    return "unreadable";
+  }
+}
+function lostCredentials(recorded, current) {
+  const now = new Map(current.map((key) => [key.name, key.hasValue]));
+  return recorded.filter((key) => key.hasValue && now.get(key.name) !== true).map((key) => key.name);
+}
+function isEnvKeyList(value) {
+  if (value === void 0)
+    return true;
+  if (!Array.isArray(value))
+    return false;
+  return value.every(
+    (key) => typeof key === "object" && key !== null && typeof key.name === "string" && typeof key.hasValue === "boolean"
+  );
+}
 function isAcceptedDrift(value) {
   if (value === void 0)
     return true;
@@ -385026,7 +385750,7 @@ function isPathAuthorization(value) {
   if (typeof value !== "object" || value === null)
     return false;
   const candidate = value;
-  return typeof candidate.reason === "string" && typeof candidate.at === "string";
+  return typeof candidate.reason === "string" && typeof candidate.at === "string" && (candidate.unplanned === void 0 || candidate.unplanned === true);
 }
 function changeBetween(captured, current) {
   if (captured === void 0)
@@ -385059,13 +385783,19 @@ function readManifest(dependencies) {
     return "malformed";
   if (typeof stored.capturedAt !== "string")
     return "malformed";
+  if (stored.implementationStartedAt !== void 0 && typeof stored.implementationStartedAt !== "string") {
+    return "malformed";
+  }
   if (!Array.isArray(stored.entries))
     return "malformed";
   const wellFormed = stored.entries.every(
-    (entry) => typeof entry === "object" && entry !== null && typeof entry.path === "string" && (entry.pathClass === "protected" || entry.pathClass === "deferred") && (entry.digest === void 0 || typeof entry.digest === "string") && isAcceptedDrift(entry.acceptedDrift) && isPathAuthorization(entry.authorization)
+    (entry) => typeof entry === "object" && entry !== null && typeof entry.path === "string" && (entry.pathClass === "protected" || entry.pathClass === "deferred") && (entry.digest === void 0 || typeof entry.digest === "string") && isAcceptedDrift(entry.acceptedDrift) && isPathAuthorization(entry.authorization) && isEnvKeyList(entry.envKeys)
   );
   return wellFormed ? stored : "malformed";
 }
+function startedMark(stored) {
+  return stored?.implementationStartedAt === void 0 ? {} : { implementationStartedAt: stored.implementationStartedAt };
+}
 function digestOf(root2, relativePath) {
   const absolute = join31(root2, relativePath);
   try {
@@ -385084,8 +385814,8 @@ function byPath(entries) {
   );
 }
 function deriveChangedPaths(root2) {
-  if (!existsSync24(join31(root2, ".git")))
-    return [];
+  if (findRepositoryRoot(root2) === void 0)
+    return "no-repository";
   let output;
   try {
     output = execFileSync5(
@@ -385140,10 +385870,14 @@ function captureEntry(root2, relativePath, derived) {
   const read = digestOf(root2, relativePath);
   if (read === "unreadable")
     return "unreadable";
+  const envKeys = isEnvPath(relativePath) ? envKeysOf(root2, relativePath) : void 0;
+  if (envKeys === "unreadable")
+    return "unreadable";
   return {
     path: relativePath,
     pathClass: derived && isGraphOwned(relativePath) ? "deferred" : "protected",
-    ...read.digest === void 0 ? {} : { digest: read.digest }
+    ...read.digest === void 0 ? {} : { digest: read.digest },
+    ...envKeys === void 0 ? {} : { envKeys }
   };
 }
 function captureProtectedPaths(dependencies, input) {
@@ -385181,7 +385915,8 @@ function captureProtectedPaths(dependencies, input) {
     if (changed === "failed") {
       return { status: "blocked", reason: "git-failed", detail: root2 };
     }
-    for (const path45 of changed)
+    const derived = changed === "no-repository" ? deriveProjectFiles(root2) : changed;
+    for (const path45 of derived)
       candidates.add(path45);
     for (const path45 of probeGraphOwned(root2, dependencies.cwd)) {
       candidates.add(path45);
@@ -385204,6 +385939,7 @@ function captureProtectedPaths(dependencies, input) {
   dependencies.store.set(protectedBaselineKey(dependencies), {
     runId: input.runId,
     capturedAt: ownBaseline?.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...startedMark(ownBaseline),
     entries
   });
   return {
@@ -385318,10 +386054,19 @@ function rebaselineProtectedPaths(dependencies, input) {
         detail: entry.path
       };
     }
+    const promotedKeys = isEnvPath(entry.path) ? envKeysOf(root2, entry.path) : void 0;
+    if (promotedKeys === "unreadable") {
+      return {
+        status: "blocked",
+        reason: "unreadable-path",
+        detail: entry.path
+      };
+    }
     const next = {
       path: entry.path,
       pathClass: "protected",
-      ...read.digest === void 0 ? {} : { digest: read.digest }
+      ...read.digest === void 0 ? {} : { digest: read.digest },
+      ...promotedKeys === void 0 ? {} : { envKeys: promotedKeys }
     };
     entries.push(next);
     promoted.push(next);
@@ -385329,6 +386074,7 @@ function rebaselineProtectedPaths(dependencies, input) {
   dependencies.store.set(protectedBaselineKey(dependencies), {
     runId: stored.runId,
     capturedAt: stored.capturedAt,
+    ...startedMark(stored),
     entries: byPath(entries)
   });
   return { status: "passed", runId: stored.runId, promoted: byPath(promoted) };
@@ -385436,16 +386182,166 @@ function acceptProtectedPathDrift(dependencies, input) {
       path: entry.path,
       pathClass: entry.pathClass,
       ...digest === void 0 ? {} : { digest },
+      // Carried rather than rebuilt. No env path reaches here today, because
+      // every one of them is graph-owned and refused above. That is a guard one
+      // edit away from changing, and dropping the record would leave the
+      // credential route refusing `unrecorded-keys` on a path it should answer.
+      ...entry.envKeys === void 0 ? {} : { envKeys: entry.envKeys },
       acceptedDrift
     });
   }
   dependencies.store.set(protectedBaselineKey(dependencies), {
     runId: stored.runId,
     capturedAt: stored.capturedAt,
+    ...startedMark(stored),
+    entries: byPath(entries)
+  });
+  return { status: "passed", runId: stored.runId, accepted: byPath(accepted) };
+}
+function acceptCredentialPlacement(dependencies, input) {
+  const root2 = resolveAnchoredRoot(dependencies);
+  const stored = readManifest(dependencies);
+  if (stored === void 0) {
+    return { status: "blocked", reason: "no-baseline", detail: input.runId };
+  }
+  if (stored === "malformed") {
+    return {
+      status: "blocked",
+      reason: "unreadable-baseline",
+      detail: input.runId
+    };
+  }
+  if (stored.runId !== input.runId) {
+    return { status: "blocked", reason: "run-mismatch", detail: stored.runId };
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const placed = /* @__PURE__ */ new Map();
+  const accepted = [];
+  for (const path45 of input.paths) {
+    const absolute = isAbsolute(path45) ? path45 : resolve7(dependencies.cwd, path45);
+    const relativePath = toRepositoryRelative(root2, absolute);
+    if (relativePath === void 0) {
+      return { status: "blocked", reason: "unknown-path", detail: path45 };
+    }
+    if (placed.has(relativePath))
+      continue;
+    if (!isEnvPath(relativePath)) {
+      return { status: "blocked", reason: "not-env-path", detail: relativePath };
+    }
+    const entry = stored.entries.find((held) => held.path === relativePath);
+    if (entry === void 0) {
+      return { status: "blocked", reason: "unknown-path", detail: relativePath };
+    }
+    if (entry.pathClass === "deferred") {
+      return {
+        status: "blocked",
+        reason: "deferred-path",
+        detail: relativePath
+      };
+    }
+    const read = digestOf(root2, relativePath);
+    if (read === "unreadable") {
+      return {
+        status: "blocked",
+        reason: "unreadable-path",
+        detail: relativePath
+      };
+    }
+    if (read.digest === entry.digest) {
+      return {
+        status: "blocked",
+        reason: "unchanged-path",
+        detail: relativePath
+      };
+    }
+    const current = envKeysOf(root2, relativePath);
+    if (current === "unreadable") {
+      return {
+        status: "blocked",
+        reason: "unreadable-path",
+        detail: relativePath
+      };
+    }
+    if (entry.envKeys === void 0) {
+      return {
+        status: "blocked",
+        reason: "unrecorded-keys",
+        detail: relativePath
+      };
+    }
+    const lost = lostCredentials(entry.envKeys, current);
+    if (lost.length > 0) {
+      return {
+        status: "blocked",
+        reason: "credential-lost",
+        detail: `${relativePath}: ${lost.join(", ")}`
+      };
+    }
+    const change = changeBetween(entry.digest, read.digest);
+    placed.set(relativePath, {
+      change,
+      at,
+      envKeys: current,
+      ...read.digest === void 0 ? {} : { digest: read.digest }
+    });
+    accepted.push({ path: relativePath, change, at });
+  }
+  const entries = [];
+  for (const entry of stored.entries) {
+    const moved = placed.get(entry.path);
+    if (moved === void 0) {
+      entries.push(entry);
+      continue;
+    }
+    const { digest, envKeys, ...acceptedDrift } = moved;
+    entries.push({
+      path: entry.path,
+      pathClass: entry.pathClass,
+      ...digest === void 0 ? {} : { digest },
+      ...entry.authorization === void 0 ? {} : { authorization: entry.authorization },
+      acceptedDrift,
+      envKeys
+    });
+  }
+  dependencies.store.set(protectedBaselineKey(dependencies), {
+    runId: stored.runId,
+    capturedAt: stored.capturedAt,
+    ...startedMark(stored),
     entries: byPath(entries)
   });
   return { status: "passed", runId: stored.runId, accepted: byPath(accepted) };
 }
+function markImplementationStarted(dependencies, input) {
+  const stored = readManifest(dependencies);
+  if (stored === void 0) {
+    return { status: "blocked", reason: "no-baseline", detail: input.runId };
+  }
+  if (stored === "malformed") {
+    return {
+      status: "blocked",
+      reason: "unreadable-baseline",
+      detail: input.runId
+    };
+  }
+  if (stored.runId !== input.runId) {
+    return { status: "blocked", reason: "run-mismatch", detail: stored.runId };
+  }
+  if (stored.implementationStartedAt !== void 0) {
+    return {
+      status: "passed",
+      runId: stored.runId,
+      startedAt: stored.implementationStartedAt
+    };
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  dependencies.store.set(protectedBaselineKey(dependencies), {
+    runId: stored.runId,
+    capturedAt: stored.capturedAt,
+    implementationStartedAt: startedAt,
+    entries: stored.entries
+  });
+  return { status: "passed", runId: stored.runId, startedAt };
+}
 function authorizeProtectedPathChange(dependencies, input) {
   const root2 = resolveAnchoredRoot(dependencies);
   const stored = readManifest(dependencies);
@@ -385468,6 +386364,7 @@ function authorizeProtectedPathChange(dependencies, input) {
   }
   const at = (/* @__PURE__ */ new Date()).toISOString();
   const granted = /* @__PURE__ */ new Map();
+  const priorDrift = /* @__PURE__ */ new Map();
   const authorized = [];
   for (const path45 of input.paths) {
     const absolute = isAbsolute(path45) ? path45 : resolve7(dependencies.cwd, path45);
@@ -385495,6 +386392,24 @@ function authorizeProtectedPathChange(dependencies, input) {
         detail: relativePath
       };
     }
+    const started = stored.implementationStartedAt !== void 0;
+    if (started && input.unplanned !== true) {
+      return {
+        status: "blocked",
+        reason: "unplanned-path",
+        detail: relativePath
+      };
+    }
+    if (!started && input.unplanned === true) {
+      return { status: "blocked", reason: "planned-path", detail: relativePath };
+    }
+    if (started && input.acceptPriorChange === true) {
+      return {
+        status: "blocked",
+        reason: "prior-change-after-start",
+        detail: relativePath
+      };
+    }
     const read = digestOf(root2, relativePath);
     if (read === "unreadable") {
       return {
@@ -385504,18 +386419,45 @@ function authorizeProtectedPathChange(dependencies, input) {
       };
     }
     if (read.digest !== entry.digest) {
-      return { status: "blocked", reason: "changed-path", detail: relativePath };
+      if (input.acceptPriorChange !== true) {
+        return {
+          status: "blocked",
+          reason: "changed-path",
+          detail: relativePath
+        };
+      }
+      priorDrift.set(relativePath, {
+        change: changeBetween(entry.digest, read.digest),
+        at,
+        ...read.digest === void 0 ? {} : { digest: read.digest }
+      });
     }
-    granted.set(relativePath, { reason, at });
-    authorized.push({ path: relativePath, reason, at });
+    const authorization = input.unplanned === true ? { reason, at, unplanned: true } : { reason, at };
+    granted.set(relativePath, authorization);
+    authorized.push({ path: relativePath, ...authorization });
   }
   const entries = stored.entries.map((entry) => {
     const authorization = granted.get(entry.path);
-    return authorization === void 0 ? entry : { ...entry, authorization };
+    if (authorization === void 0)
+      return entry;
+    const moved = priorDrift.get(entry.path);
+    if (moved === void 0)
+      return { ...entry, authorization };
+    const { digest, ...acceptedDrift } = moved;
+    return {
+      path: entry.path,
+      pathClass: entry.pathClass,
+      ...digest === void 0 ? {} : { digest },
+      // Carried for the same reason as in the acceptance route above.
+      ...entry.envKeys === void 0 ? {} : { envKeys: entry.envKeys },
+      acceptedDrift,
+      authorization
+    };
   });
   dependencies.store.set(protectedBaselineKey(dependencies), {
     runId: stored.runId,
     capturedAt: stored.capturedAt,
+    ...startedMark(stored),
     entries: byPath(entries)
   });
   return {
@@ -385524,26 +386466,55 @@ function authorizeProtectedPathChange(dependencies, input) {
     authorized: byPath(authorized)
   };
 }
-var GRAPH_OWNED_SUFFIXES;
+var SKIPPED_DIRECTORIES3, GRAPH_OWNED_SUFFIXES;
 var init_onboarding_protected_paths = __esm({
   "apps/cli/src/services/onboarding-protected-paths.ts"() {
     "use strict";
+    init_dotenv_read();
+    init_repository_root();
     init_onboarding_state();
+    SKIPPED_DIRECTORIES3 = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      "coverage",
+      ".next",
+      "venv",
+      "__pycache__"
+    ]);
     GRAPH_OWNED_SUFFIXES = [".env", ".copilotkit/project.json"];
   }
 });
 
 // apps/cli/src/services/onboarding-classification.ts
-function unprovenBaselineRefusal(startingState, route) {
-  if (startingState !== "both-oss")
+function unprovenBaselineRefusal(startingState, route, proof) {
+  if (startingState !== "both-oss" && startingState !== "both-copilotkit-unproved") {
     return void 0;
-  if (route.length === 0)
+  }
+  if (route.length > 0 && !route.includes(OSS_BASELINE_NODE)) {
+    return `--starting-state ${startingState} records a project whose CopilotKit integration was reached, and this run never served ${OSS_BASELINE_NODE}.
+Its route is: ${route.join(",")}.
+Read ${OSS_BASELINE_NODE} and record the state its proof returns.`;
+  }
+  if (proof === void 0)
     return void 0;
-  if (route.includes(OSS_BASELINE_NODE))
+  if (startingState === "both-oss") {
+    return proof.outcome === "passed" ? void 0 : `--starting-state both-oss records a proved OSS baseline, and this run recorded that baseline as ${proof.outcome}.
+Record --starting-state both-copilotkit-unproved instead: the CopilotKit integration is present and its round trip did not prove.`;
+  }
+  return proof.outcome === "passed" ? `--starting-state both-copilotkit-unproved records a round trip that did not prove, and this run recorded its baseline as passed.
+Record --starting-state both-oss instead, and keep the proof evidence with the plan.` : void 0;
+}
+function contradictedIntegrationRefusal(startingState, route) {
+  if (!ABSENCE_STATES.some((state) => state === startingState)) {
+    return void 0;
+  }
+  if (!route.includes(OSS_BASELINE_NODE))
     return void 0;
-  return `--starting-state both-oss records a proved OSS baseline, and this run never served ${OSS_BASELINE_NODE}.
+  return `--starting-state ${startingState} records a project without a CopilotKit integration, and this run was served ${OSS_BASELINE_NODE}, which is reached only when an agent, a frontend and a CopilotKit integration are all proved present.
 Its route is: ${route.join(",")}.
-Read ${OSS_BASELINE_NODE} and record the state its proof returns.`;
+Record --starting-state both-oss for a baseline that proved, or --starting-state both-copilotkit-unproved for one that did not.`;
 }
 function unresearchedBaselineWarning(promptName, route) {
   if (promptName !== OSS_BASELINE_NODE)
@@ -385563,7 +386534,7 @@ function requireOnboardingChoice(flag, value, choices) {
   }
   return selected;
 }
-var ONBOARDING_STARTING_STATES, ONBOARDING_AGENT_FRAMEWORKS, ONBOARDING_FRONTENDS, OSS_BASELINE_NODE, TERMINAL_NODES, REPOSITORY_RESEARCH_NODE;
+var ONBOARDING_STARTING_STATES, ONBOARDING_AGENT_FRAMEWORKS, ONBOARDING_FRONTENDS, ONBOARDING_PROOF_STEPS, ONBOARDING_PROOF_OUTCOMES, ABSENCE_STATES, OSS_BASELINE_NODE, TERMINAL_NODES, REPOSITORY_RESEARCH_NODE;
 var init_onboarding_classification = __esm({
   "apps/cli/src/services/onboarding-classification.ts"() {
     "use strict";
@@ -385572,6 +386543,7 @@ var init_onboarding_classification = __esm({
       "agent-only",
       "frontend-only",
       "both",
+      "both-copilotkit-unproved",
       "both-oss"
     ];
     ONBOARDING_AGENT_FRAMEWORKS = [
@@ -385602,6 +386574,18 @@ var init_onboarding_classification = __esm({
       "vue",
       "react-native"
     ];
+    ONBOARDING_PROOF_STEPS = ["oss-baseline", "round-trip"];
+    ONBOARDING_PROOF_OUTCOMES = [
+      "passed",
+      "failed",
+      "skipped"
+    ];
+    ABSENCE_STATES = [
+      "empty",
+      "agent-only",
+      "frontend-only",
+      "both"
+    ];
     OSS_BASELINE_NODE = "proof/oss-baseline";
     TERMINAL_NODES = {
       "fallback/best-effort": "best-effort",
@@ -385780,7 +386764,7 @@ async function runOnboard(argv, dependencies) {
       deps,
       () => deps.loadStartPrompt(parsed.values.intent)
     );
-    const binding2 = startOnboardingRun(
+    const binding = startOnboardingRun(
       {
         cwd: deps.cwd,
         store: deps.store,
@@ -385791,14 +386775,39 @@ async function runOnboard(argv, dependencies) {
     );
     recordStarted(
       deps,
-      binding2.runId,
+      binding.runId,
       "start",
-      binding2.idOrigin,
+      binding.idOrigin,
       parsed.values["coding-agent"]
     );
-    printRunId(deps, binding2.runId);
+    if (parsed.values["coding-agent"] !== void 0) {
+      recordCodingAgentBestEffort(
+        deps,
+        binding.runId,
+        parsed.values["coding-agent"]
+      );
+    }
+    printRunId(deps, binding.runId);
     await printGraphTree(deps);
-    writePrompt(deps, binding2.runId, startPrompt);
+    writePrompt(deps, binding.runId, startPrompt);
+    return;
+  }
+  if (subcommand === "identify") {
+    const parsed = parseIdentify(argv.slice(1));
+    const runId2 = requireBoundRun(deps, IDENTIFY_RUN_NOT_BOUND);
+    recordCodingAgentBestEffort(deps, runId2, parsed.codingAgent);
+    recordBestEffort(deps, {
+      event: "cli.onboarding.identified",
+      properties: {
+        command: "onboard",
+        ...onboardingIntentProperties(deps),
+        onboarding_run_id: runId2,
+        cli_version: deps.cliVersion,
+        coding_agent: normalizeCodingAgent(parsed.codingAgent)
+      }
+    });
+    deps.stdout.write(`Coding agent recorded for run ${runId2}.
+`);
     return;
   }
   if (subcommand === "route") {
@@ -385812,23 +386821,21 @@ async function runOnboard(argv, dependencies) {
     if (argv.length !== 2 || promptName === void 0) {
       throw new Error("Usage: copilotkit onboard read <prompt-name>");
     }
-    await printPrompt(deps, requireBoundRun(deps), promptName);
+    await printPrompt(
+      deps,
+      requireBoundRun(deps, READ_RUN_NOT_BOUND),
+      promptName
+    );
     return;
   }
-  const binding = resolveOnboardingRun({
-    cwd: deps.cwd,
-    store: deps.store,
-    randomRunId: deps.randomRunId
-  });
-  if (binding.started) {
-    recordStarted(
-      deps,
-      binding.runId,
-      "another-step",
-      binding.idOrigin,
-      void 0
+  if (subcommand === void 0 || !ONBOARD_SUBCOMMANDS.includes(subcommand)) {
+    throw new Error(
+      `Usage: copilotkit onboard <${ONBOARD_SUBCOMMANDS.join("|")}>`
     );
   }
+  const runId = readOnboardingRunId({ cwd: deps.cwd, store: deps.store });
+  if (runId === void 0)
+    throw new Error(STEP_RUN_NOT_BOUND);
   if (subcommand === "complete") {
     const opened = parseFrontendUrl(argv.slice(1));
     if (opened === void 0)
@@ -385839,14 +386846,14 @@ async function runOnboard(argv, dependencies) {
     const check4 = parseSurfaceCheck(blocked2.rest);
     if (check4 === void 0)
       throw new Error(SURFACE_CHECK_USAGE);
-    const accepted = readAcceptedDriftBestEffort(deps, binding.runId);
-    const authorized = readAuthorizationsBestEffort(deps, binding.runId);
+    const accepted = readAcceptedDriftBestEffort(deps, runId);
+    const authorized = readAuthorizationsBestEffort(deps, runId);
     recordBestEffort(deps, {
       event: "cli.onboarding.completed",
       properties: {
         command: "onboard",
         ...onboardingIntentProperties(deps),
-        onboarding_run_id: binding.runId,
+        onboarding_run_id: runId,
         cli_version: deps.cliVersion,
         accepted_count: accepted.length,
         authorized_count: authorized.length,
@@ -385882,7 +386889,7 @@ async function runOnboard(argv, dependencies) {
     const requestedFramework = parsed.values["agent-framework"];
     const startingState = reportingRefusal(
       deps,
-      binding.runId,
+      runId,
       "starting-state-invalid",
       {},
       () => requireOnboardingChoice(
@@ -385893,7 +386900,7 @@ async function runOnboard(argv, dependencies) {
     );
     const agentFramework = reportingRefusal(
       deps,
-      binding.runId,
+      runId,
       "agent-framework-invalid",
       { requested_agent_framework: reportableSlug(requestedFramework) },
       () => requireOnboardingChoice(
@@ -385904,7 +386911,7 @@ async function runOnboard(argv, dependencies) {
     );
     const frontend = reportingRefusal(
       deps,
-      binding.runId,
+      runId,
       "frontend-invalid",
       {},
       () => requireOnboardingChoice(
@@ -385913,12 +386920,19 @@ async function runOnboard(argv, dependencies) {
         ONBOARDING_FRONTENDS
       )
     );
+    const route = readOnboardingRoute({ cwd: deps.cwd, store: deps.store });
+    const contradiction = contradictedIntegrationRefusal(startingState, route);
+    if (contradiction !== void 0) {
+      recordClassifyRefusal(deps, runId, "integration-contradicted", {});
+      throw new Error(contradiction);
+    }
     const refusal = unprovenBaselineRefusal(
       startingState,
-      readOnboardingRoute({ cwd: deps.cwd, store: deps.store })
+      route,
+      readBaselineProofBestEffort(deps)
     );
     if (refusal !== void 0) {
-      recordClassifyRefusal(deps, binding.runId, "baseline-unproven", {});
+      recordClassifyRefusal(deps, runId, "baseline-unproven", {});
       throw new Error(refusal);
     }
     recordBestEffort(deps, {
@@ -385926,7 +386940,7 @@ async function runOnboard(argv, dependencies) {
       properties: {
         command: "onboard",
         ...onboardingIntentProperties(deps),
-        onboarding_run_id: binding.runId,
+        onboarding_run_id: runId,
         cli_version: deps.cliVersion,
         starting_state: startingState,
         // Mapped at the emit boundary, never at the flag: the graph's own
@@ -385943,11 +386957,11 @@ async function runOnboard(argv, dependencies) {
     if (argv.length !== 1) {
       throw new Error("Usage: copilotkit onboard feedback");
     }
-    await reportFeedback(deps, binding.runId);
+    await reportFeedback(deps, runId);
     return;
   }
   if (subcommand === "friction") {
-    await reportFriction(deps, binding.runId, argv.slice(1));
+    await reportFriction(deps, runId, argv.slice(1));
     return;
   }
   if (subcommand === "protect") {
@@ -385955,11 +386969,14 @@ async function runOnboard(argv, dependencies) {
       args: [...argv.slice(1)],
       allowPositionals: false,
       options: {
+        "accept-credential": { type: "boolean" },
         "accept-external": { type: "boolean" },
         authorize: { type: "boolean" },
         path: { type: "string", multiple: true },
         reason: { type: "string" },
-        rebaseline: { type: "boolean" }
+        rebaseline: { type: "boolean" },
+        unplanned: { type: "boolean" },
+        "with-prior-change": { type: "boolean" }
       },
       strict: true
     });
@@ -385967,21 +386984,52 @@ async function runOnboard(argv, dependencies) {
     const target = { cwd: deps.cwd, store: deps.store };
     const rebaseline = parsed.values.rebaseline === true;
     const acceptExternal = parsed.values["accept-external"] === true;
+    const acceptCredential = parsed.values["accept-credential"] === true;
     const authorize = parsed.values.authorize === true;
-    if ([rebaseline, acceptExternal, authorize].filter(Boolean).length > 1) {
+    const withPriorChange = parsed.values["with-prior-change"] === true;
+    const unplanned = parsed.values.unplanned === true;
+    if ([rebaseline, acceptExternal, acceptCredential, authorize].filter(Boolean).length > 1) {
       throw new Error(EXCLUSIVE_MODE_USAGE);
     }
+    if (withPriorChange && !authorize) {
+      throw new Error(PRIOR_CHANGE_USAGE);
+    }
+    if (unplanned && !authorize) {
+      throw new Error(UNPLANNED_USAGE);
+    }
+    if (acceptCredential) {
+      if (paths.length === 0)
+        throw new Error(ACCEPT_CREDENTIAL_USAGE);
+      const placed = acceptCredentialPlacement(target, {
+        runId,
+        paths
+      });
+      recordProtect(
+        deps,
+        runId,
+        "accept-credential",
+        placed,
+        (result) => ({
+          path_count: result.accepted.length,
+          drift_kinds: joinChanges(result.accepted.map((one) => one.change))
+        })
+      );
+      deps.stdout.write(credentialReport(placed));
+      return;
+    }
     if (authorize) {
       const reason = parsed.values.reason ?? "";
       if (paths.length === 0 || reason.trim() === "") {
         throw new Error(AUTHORIZE_USAGE);
       }
       const authorized = authorizeProtectedPathChange(target, {
-        runId: binding.runId,
+        runId,
         paths,
-        reason
+        reason,
+        acceptPriorChange: withPriorChange,
+        unplanned
       });
-      recordProtect(deps, binding.runId, "authorize", authorized, (result) => ({
+      recordProtect(deps, runId, "authorize", authorized, (result) => ({
         path_count: result.authorized.length
       }));
       deps.stdout.write(authorizationReport(authorized));
@@ -385991,10 +387039,10 @@ async function runOnboard(argv, dependencies) {
       if (paths.length === 0)
         throw new Error(ACCEPT_USAGE);
       const accepted = acceptProtectedPathDrift(target, {
-        runId: binding.runId,
+        runId,
         paths
       });
-      recordProtect(deps, binding.runId, "accept", accepted, (result) => ({
+      recordProtect(deps, runId, "accept", accepted, (result) => ({
         path_count: result.accepted.length,
         drift_kinds: joinChanges(result.accepted.map((one) => one.change))
       }));
@@ -386005,20 +387053,20 @@ async function runOnboard(argv, dependencies) {
       if (paths.length === 0)
         throw new Error(REBASELINE_USAGE);
       const promoted = rebaselineProtectedPaths(target, {
-        runId: binding.runId,
+        runId,
         paths
       });
-      recordProtect(deps, binding.runId, "rebaseline", promoted, (result) => ({
+      recordProtect(deps, runId, "rebaseline", promoted, (result) => ({
         path_count: result.promoted.length
       }));
       deps.stdout.write(rebaselineReport(promoted));
       return;
     }
     const captured = captureProtectedPaths(target, {
-      runId: binding.runId,
+      runId,
       paths
     });
-    recordProtect(deps, binding.runId, "capture", captured, (result) => ({
+    recordProtect(deps, runId, "capture", captured, (result) => ({
       path_count: result.added.length,
       protect_derived: result.derived
     }));
@@ -386026,17 +387074,21 @@ async function runOnboard(argv, dependencies) {
     return;
   }
   if (subcommand === "checkpoint") {
-    reportCheckpoint(deps, binding.runId, argv.slice(1));
+    reportCheckpoint(deps, runId, argv.slice(1));
     return;
   }
   if (subcommand === "proof") {
     const proof = parseProof(argv.slice(1));
+    recordProofBestEffort(deps, runId, proof.step, {
+      outcome: proof.outcome,
+      ...proof.predicate === void 0 ? {} : { predicate: proof.predicate }
+    });
     recordBestEffort(deps, {
       event: "cli.onboarding.proof_recorded",
       properties: {
         command: "onboard",
         ...onboardingIntentProperties(deps),
-        onboarding_run_id: binding.runId,
+        onboarding_run_id: runId,
         cli_version: deps.cliVersion,
         proof_step: proof.step,
         proof_outcome: proof.outcome,
@@ -386053,14 +387105,14 @@ async function runOnboard(argv, dependencies) {
       throw new Error("Usage: copilotkit onboard audit");
     const audit = auditProtectedPaths(
       { cwd: deps.cwd, store: deps.store },
-      { runId: binding.runId }
+      { runId }
     );
     recordBestEffort(deps, {
       event: "cli.onboarding.audit_completed",
       properties: {
         command: "onboard",
         ...onboardingIntentProperties(deps),
-        onboarding_run_id: binding.runId,
+        onboarding_run_id: runId,
         cli_version: deps.cliVersion,
         ...describeAudit(audit)
       }
@@ -386068,17 +387120,17 @@ async function runOnboard(argv, dependencies) {
     deps.stdout.write(auditReport(audit));
     return;
   }
-  throw new Error(
-    `Usage: copilotkit onboard <${ONBOARD_SUBCOMMANDS.join("|")}>`
-  );
 }
-function requireBoundRun(dependencies) {
+function runNotBound(reason) {
+  return "No onboarding run is bound to this directory.\n\n" + reason + "\n\nIf this session has not started, run `copilotkit onboard start` here.\nIf it has, run `copilotkit onboard start --run <id>` here with the id the\nfirst start printed, or run this command from the directory you started in.\n\nThis is a missing start, not a failed step: nothing has been proved\nunsupported.";
+}
+function requireBoundRun(dependencies, refusal) {
   const runId = readOnboardingRunId({
     cwd: dependencies.cwd,
     store: dependencies.store
   });
   if (runId === void 0)
-    throw new Error(RUN_NOT_BOUND);
+    throw new Error(refusal);
   return runId;
 }
 function plural(count, noun) {
@@ -386164,6 +387216,59 @@ ${detail}`;
     ""
   ].join("\n");
 }
+function credentialReport(result) {
+  if (result.status === "blocked") {
+    const detail = {
+      "no-baseline": `No protected-path baseline was captured for run ${result.detail}.
+Run \`copilotkit onboard protect\` first.
+`,
+      "run-mismatch": `The captured baseline belongs to run ${result.detail}, not to this run.
+A credential can only be accepted against the baseline of the run that
+asked for it.
+`,
+      "unreadable-baseline": `The captured baseline for run ${result.detail} could not be read.
+Capture it again before accepting anything against it.
+`,
+      "unreadable-path": `The protected path \`${result.detail}\` could not be read, so the credential
+it now holds could not be checked.
+`,
+      "unknown-path": `The path \`${result.detail}\` is not in this run\u2019s baseline.
+Only a captured path can be accepted.
+`,
+      "deferred-path": `The path \`${result.detail}\` is deferred, not protected.
+This graph has not finished writing it, so promote it first with
+\`onboard protect --rebaseline --path <path>\`.
+`,
+      "not-env-path": `The path \`${result.detail}\` is not an env file.
+This route reads variable names to prove no credential was lost, which only
+means something for a file of \`KEY=value\` lines.
+`,
+      "unchanged-path": `The path \`${result.detail}\` matches the digest captured for it.
+Nothing was placed in it, so there is no credential to accept.
+`,
+      "unrecorded-keys": `The baseline holds no variable names for \`${result.detail}\`.
+This route proves no credential was lost by comparing them, so with none
+recorded it can prove nothing. Capture the path again with
+\`onboard protect --path <path>\` before the developer writes to it.
+`,
+      "credential-lost": `A credential recorded for \`${result.detail}\` is gone.
+This route accepts a credential the developer added. It refuses a change
+that drops one, which is the failure the baseline exists to catch. Do not
+repair or rewrite the file. Report the missing variable and route out.
+`
+    }[result.reason];
+    return `Status: blocked
+${detail}${NOTHING_ACCEPTED}`;
+  }
+  return [
+    "Status: passed",
+    `Accepted the placed credential in ${plural(result.accepted.length, "env file")} for run ${result.runId}.`,
+    ...result.accepted.map(changeLine),
+    "Every credential the baseline recorded is still there.",
+    "Report each accepted path in the summary.",
+    ""
+  ].join("\n");
+}
 function acceptanceReport(result) {
   if (result.status === "blocked") {
     const detail = {
@@ -386217,7 +387322,8 @@ ${detail}${NOTHING_ACCEPTED}`;
   ].join("\n");
 }
 function authorizationLine(granted) {
-  return `  ${granted.path}  \u2014  ${granted.reason}`;
+  const source = granted.unplanned === true ? "  (outside the approved plan)" : "";
+  return `  ${granted.path}  \u2014  ${granted.reason}${source}`;
 }
 function authorizedLines(authorized) {
   return authorized.length === 0 ? [] : ["Authorized to change:", ...authorized.map(authorizationLine)];
@@ -386249,11 +387355,31 @@ Nothing outside the run writes it, so consent here would only license the
 run against its own credential output.
 `,
       "missing-reason": "No reason was given.\nConsent is recorded so the closing report can tell the developer what their\nfile was changed for. A blank reason records permission and no answer.\n",
+      "unplanned-path": `The path \`${result.detail}\` is not one the approved plan asked for.
+This run has already reported its plan, so the developer has approved every
+path they are going to approve. They did not approve this one. Ask them
+to allow the change, and record the answer they give with
+\`onboard protect --authorize --unplanned --path <path> --reason "<their
+answer>"\`. If you cannot ask, route out. Do not repair the path.
+`,
+      "prior-change-after-start": `The path \`${result.detail}\` cannot carry a prior-change claim any more.
+That claim says the developer changed the file before this run implemented
+anything, and this run has already reported its plan. A protected path that
+changed after that is this run\u2019s own work. Route out rather than record
+consent over it.
+`,
+      "planned-path": `The path \`${result.detail}\` can still be authorized by the plan itself.
+This run has not reported its plan yet, so --unplanned describes nothing:
+consent here is the developer approving the plan. Record it without the
+flag, or add the path to the plan and have the developer approve that.
+`,
       "changed-path": `The path \`${result.detail}\` has already changed since it was captured.
 Consent has to be recorded before the change, or it cannot be told apart from
 a run clearing a failure it caused. Run \`onboard audit\`: if a Files changed
-section from this run names the path, route out; if none does, accept it with
-\`onboard protect --accept-external --path <path>\` instead.
+section from this run names the path, route out. If none does, the developer
+changed it, and either accept it with \`onboard protect --accept-external
+--path <path>\` or, when this run must change the same file, record consent
+over their change by adding --with-prior-change.
 `
     }[result.reason];
     return `Status: blocked
@@ -386385,6 +387511,24 @@ function parseProof(args) {
   }
   return { step, outcome, predicate };
 }
+function parseIdentify(args) {
+  let parsed;
+  try {
+    parsed = parseArgs2({
+      args: [...args],
+      allowPositionals: false,
+      options: { "coding-agent": { type: "string" } },
+      strict: true
+    });
+  } catch {
+    throw new Error(IDENTIFY_USAGE);
+  }
+  const codingAgent = parsed.values["coding-agent"];
+  if (codingAgent === void 0 || codingAgent.trim().length === 0) {
+    throw new Error(IDENTIFY_USAGE);
+  }
+  return { codingAgent };
+}
 function reportCheckpoint(dependencies, runId, args) {
   let parsed;
   try {
@@ -386410,6 +387554,12 @@ function reportCheckpoint(dependencies, runId, args) {
   if (!reviewed.ok) {
     return printCheckpointRefusal(dependencies, runId, reviewed.refusal);
   }
+  if (reviewed.checkpoint.phase === "plan-written") {
+    markImplementationStarted(
+      { cwd: dependencies.cwd, store: dependencies.store },
+      { runId }
+    );
+  }
   recordBestEffort(dependencies, {
     event: "cli.onboarding.checkpoint",
     properties: {
@@ -386623,9 +387773,9 @@ async function reportFeedback(dependencies, runId) {
   if (!reviewed.ok)
     return printFeedbackRefusal(dependencies, runId, reviewed.refusal);
   const feedbackText = reviewed.text;
-  let sent = false;
+  let submission;
   try {
-    sent = await dependencies.submitFeedbackEvent({
+    submission = await dependencies.submitFeedbackEvent({
       event: "cli.onboarding.feedback_submitted",
       properties: {
         command: "onboard",
@@ -386635,15 +387785,25 @@ async function reportFeedback(dependencies, runId) {
         feedback_text: feedbackText
       }
     });
-  } catch {
-    sent = false;
+  } catch (error98) {
+    submission = { status: "failed", detail: describeSubmissionError(error98) };
   }
   dependencies.stdout.write(
-    `${sent ? "Feedback sent." : "Feedback was not sent because telemetry is disabled or unavailable."}
+    `${describeSubmission("Feedback", submission)}
 report: ${feedbackText}
 `
   );
 }
+function describeSubmission(subject, submission) {
+  switch (submission.status) {
+    case "sent":
+      return subject === "Feedback" ? "Feedback sent." : "Friction reported.";
+    case "declined":
+      return `${subject} was not sent because telemetry is off.`;
+    default:
+      return `${subject} was not sent because the telemetry send failed: ${submission.detail}`;
+  }
+}
 function printFeedbackRefusal(dependencies, runId, refusal) {
   recordReportRefused(dependencies, runId, "feedback", refusal.code);
   dependencies.stdout.write(
@@ -386668,9 +387828,9 @@ async function reportFriction(dependencies, runId, args) {
   if (!reviewed.ok)
     return printFrictionRefusal(dependencies, runId, reviewed.refusal);
   const report = reviewed.report;
-  let sent = false;
+  let submission;
   try {
-    sent = await dependencies.submitFeedbackEvent({
+    submission = await dependencies.submitFeedbackEvent({
       event: "cli.onboarding.friction_reported",
       properties: {
         command: "onboard",
@@ -386685,10 +387845,10 @@ async function reportFriction(dependencies, runId, args) {
         friction_text: report.text
       }
     });
-  } catch {
-    sent = false;
+  } catch (error98) {
+    submission = { status: "failed", detail: describeSubmissionError(error98) };
   }
-  printFrictionReport(dependencies, report, sent);
+  printFrictionReport(dependencies, report, submission);
 }
 function parseFrictionArguments(args) {
   try {
@@ -386726,9 +387886,9 @@ ${refusal.code}: ${refusal.message}
 `
   );
 }
-function printFrictionReport(dependencies, report, sent) {
+function printFrictionReport(dependencies, report, submission) {
   dependencies.stdout.write(
-    `${sent ? "Friction reported." : "Friction was not sent because telemetry is disabled or unavailable."}
+    `${describeSubmission("Friction", submission)}
 category: ${report.category}
 cost_seconds_estimated: ${report.costSecondsEstimated}
 ` + (report.docsPath === void 0 ? "" : `docs_path: ${report.docsPath}
@@ -386896,6 +388056,37 @@ function readRouteBestEffort(dependencies) {
     return [];
   }
 }
+function recordProofBestEffort(dependencies, runId, step, proof) {
+  try {
+    recordProofOutcome(
+      { cwd: dependencies.cwd, store: dependencies.store },
+      runId,
+      step,
+      proof
+    );
+  } catch {
+  }
+}
+function recordCodingAgentBestEffort(dependencies, runId, codingAgent) {
+  try {
+    recordCodingAgent(
+      { cwd: dependencies.cwd, store: dependencies.store },
+      runId,
+      codingAgent
+    );
+  } catch {
+  }
+}
+function readBaselineProofBestEffort(dependencies) {
+  try {
+    return readProofOutcome(
+      { cwd: dependencies.cwd, store: dependencies.store },
+      "oss-baseline"
+    );
+  } catch {
+    return void 0;
+  }
+}
 function recordRouteBestEffort(dependencies, runId, promptName) {
   try {
     recordServedPrompt(
@@ -386919,7 +388110,7 @@ function recordBestEffort(dependencies, event) {
   } catch {
   }
 }
-var ONBOARD_SUBCOMMANDS, RUN_NOT_BOUND, REBASELINE_USAGE, ACCEPT_USAGE, AUTHORIZE_USAGE, EXCLUSIVE_MODE_USAGE, NOTHING_PROVED, NOTHING_AUTHORIZED, NOTHING_ACCEPTED, VISUAL_CHECK_OUTCOMES, DEVICE_CHECK_OUTCOMES, BLOCKER_CAUSES, BLOCKER_USAGE, SURFACE_CHECK_USAGE, FRONTEND_URL_USAGE, PROOF_STEPS, PROOF_OUTCOMES, BASELINE_PREDICATE_COUNT, PROOF_USAGE, BLOCKER_REPORTS;
+var ONBOARD_SUBCOMMANDS, READ_RUN_NOT_BOUND, IDENTIFY_RUN_NOT_BOUND, STEP_RUN_NOT_BOUND, REBASELINE_USAGE, ACCEPT_USAGE, AUTHORIZE_USAGE, ACCEPT_CREDENTIAL_USAGE, PRIOR_CHANGE_USAGE, UNPLANNED_USAGE, EXCLUSIVE_MODE_USAGE, NOTHING_PROVED, NOTHING_AUTHORIZED, NOTHING_ACCEPTED, VISUAL_CHECK_OUTCOMES, DEVICE_CHECK_OUTCOMES, BLOCKER_CAUSES, BLOCKER_USAGE, SURFACE_CHECK_USAGE, FRONTEND_URL_USAGE, PROOF_STEPS, PROOF_OUTCOMES, BASELINE_PREDICATE_COUNT, PROOF_USAGE, IDENTIFY_USAGE, BLOCKER_REPORTS;
 var init_onboard = __esm({
   async "apps/cli/src/commands/onboard.ts"() {
     "use strict";
@@ -386940,6 +388131,7 @@ var init_onboard = __esm({
     init_resolved_dependencies();
     ONBOARD_SUBCOMMANDS = [
       "start",
+      "identify",
       "read",
       "route",
       "classify",
@@ -386951,11 +388143,22 @@ var init_onboard = __esm({
       "feedback",
       "friction"
     ];
-    RUN_NOT_BOUND = "No onboarding run is bound to this directory.\n\n`onboard read` reports every node it serves against the run `onboard start`\ndeclared. Minting one here would record this directory as a second run of a\nsession that already has one, and leave the first looking like a stall.\n\nIf this session has not started, run `copilotkit onboard start` here.\nIf it has, run `copilotkit onboard start --run <id>` here with the id the\nfirst start printed, or read from the directory you started in.\n\nThis is a missing start, not a failed step: nothing has been proved\nunsupported.";
+    READ_RUN_NOT_BOUND = runNotBound(
+      "`onboard read` reports every node it serves against the run `onboard start`\ndeclared. Minting one here would record this directory as a second run of a\nsession that already has one, and leave the first looking like a stall."
+    );
+    IDENTIFY_RUN_NOT_BOUND = runNotBound(
+      "`onboard identify` records the coding agent against the run `onboard start`\ndeclared. Minting one here would file this identify, and the login that\nfollows it, under a run no other step in the session ever reports against."
+    );
+    STEP_RUN_NOT_BOUND = runNotBound(
+      "This step reports against the run `onboard start` declared. Minting one here\nwould bind a second run to this directory alone, and take the route, the\nprotected baseline and the proof record with it."
+    );
     REBASELINE_USAGE = "Usage: copilotkit onboard protect --rebaseline --path <path> [--path <path>]\nName the paths to re-capture. A re-baseline with no path would be a request to\nre-read the whole baseline, which is the one thing this command must never do.";
     ACCEPT_USAGE = "Usage: copilotkit onboard protect --accept-external --path <path> [--path <path>]\nName the paths to accept. An acceptance with no path would accept every change\nthis run has not seen, which is the one thing this command must never do.";
     AUTHORIZE_USAGE = "Usage: copilotkit onboard protect --authorize --path <path> [--path <path>]\n  --reason <why this run must change it>\nName the paths and say why. Consent with no path would license every file the\ndeveloper owns, and consent with no reason leaves the closing report unable to\ntell them what their file was changed for.";
-    EXCLUSIVE_MODE_USAGE = "Use one of --rebaseline, --accept-external or --authorize, not more than one.\n--rebaseline records a file this run wrote. --accept-external records a change\nthat came from outside the run. --authorize records the developer allowing this\nrun to change a file of theirs. One path cannot be more than one of them.";
+    ACCEPT_CREDENTIAL_USAGE = "Usage: copilotkit onboard protect --accept-credential --path <path> [--path <path>]\nName the env files whose new credential you accept. This route checks that no\ncredential the baseline recorded was lost, so it needs the paths to check.";
+    PRIOR_CHANGE_USAGE = "--with-prior-change belongs to --authorize and to nothing else.\nIt widens one authorization to cover a change the developer already made to\nthe path. No other mode records consent, so nothing there can carry it.";
+    UNPLANNED_USAGE = "--unplanned belongs to --authorize and to nothing else.\nIt records that the developer gave this consent mid-run, after the approved\nplan was settled. No other mode records consent, so nothing there can carry it.";
+    EXCLUSIVE_MODE_USAGE = "Use one of --rebaseline, --accept-external, --accept-credential or --authorize,\nnot more than one. --rebaseline records a file this run wrote.\n--accept-external records a change that came from outside the run.\n--accept-credential records a credential the developer placed in an env file\nbecause the run asked. --authorize records the developer allowing this run to\nchange a file of theirs. One path cannot be more than one of them.";
     NOTHING_PROVED = "This is a missing baseline, not a preservation failure: no protected path has\nbeen proved changed, and none has been proved unchanged either.\n";
     NOTHING_AUTHORIZED = "Nothing was recorded. No path in this call was authorized, including any path\nnamed before the one above.\n";
     NOTHING_ACCEPTED = "Nothing was recorded. No path in this call was accepted, including any path\nnamed before the one above.\n";
@@ -386982,8 +388185,8 @@ blocked reads the unsupported terminal instead, and reports a path that works
 as one this release does not carry.`;
     SURFACE_CHECK_USAGE = "Usage: copilotkit onboard complete --visual-check <performed|skipped-no-browser-tool|failed>\n   or: copilotkit onboard complete --device-check <performed|skipped-no-device|failed>\nPass exactly one. A web journey is proven in a browser and a mobile one on a device;\nwhich flag you pass is how this run states which surface it proved.";
     FRONTEND_URL_USAGE = "Usage: copilotkit onboard complete <surface-check> --frontend-url <absolute url>\nPass the URL a browser actually opened, for example http://localhost:3000.\nOnly the kind of host is recorded -- loopback hostname, loopback IP literal,\nother IP literal, other name -- never the host itself.";
-    PROOF_STEPS = ["oss-baseline", "round-trip"];
-    PROOF_OUTCOMES = ["passed", "failed", "skipped"];
+    PROOF_STEPS = ONBOARDING_PROOF_STEPS;
+    PROOF_OUTCOMES = ONBOARDING_PROOF_OUTCOMES;
     BASELINE_PREDICATE_COUNT = 6;
     PROOF_USAGE = `Usage: copilotkit onboard proof --step <${PROOF_STEPS.join("|")}> --outcome <${PROOF_OUTCOMES.join("|")}>
                                [--predicate <1-${BASELINE_PREDICATE_COUNT}>]
@@ -386994,6 +388197,7 @@ trip.
 Pass --predicate with a failed or skipped oss-baseline to name which of the
 six predicates it was. A passed gate has no predicate to name, and the
 round trip has no numbered predicates at all.`;
+    IDENTIFY_USAGE = "Usage: copilotkit onboard identify --coding-agent <slug>";
     BLOCKER_REPORTS = {
       inspector: {
         cause: "the debugging surface for this frontend did not open.",
@@ -389970,6 +391174,7 @@ init_feature_flags();
 init_exit_code();
 init_unknown_input();
 await init_telemetry();
+init_event_properties();
 import { parseArgs as parseArgs4 } from "node:util";
 import { realpathSync as realpathSync3 } from "node:fs";
 import path44 from "node:path";
@@ -390217,12 +391422,15 @@ Options:
   -h, --help             Show help for login
 `,
   onboard: `Usage: copilotkit onboard start [--intent <slug>] [--run <id>] [--coding-agent <slug>]
+       copilotkit onboard identify --coding-agent <slug>
        copilotkit onboard read <prompt-name>
        copilotkit onboard route
        copilotkit onboard classify --starting-state <state> --agent-framework <framework> --frontend <frontend>
        copilotkit onboard protect [--path <path>] [--rebaseline --path <path>]
                                   [--accept-external --path <path>]
-                                  [--authorize --path <path> --reason <why>]
+                                  [--accept-credential --path <path>]
+                                  [--authorize --path <path> --reason <why>
+                                   [--with-prior-change] [--unplanned]]
        copilotkit onboard audit
        copilotkit onboard checkpoint --phase <slug> [--attempt <n>]
        copilotkit onboard proof --step <oss-baseline|round-trip> --outcome <passed|failed|skipped>
@@ -390249,7 +391457,7 @@ Subcommands:
 
 Feedback must be no larger than 2,048 UTF-8 bytes. Do not include secrets,
 source code, logs, or command output. The global telemetry setting applies.
-When telemetry is disabled or unavailable, feedback exits zero and is not sent.
+When telemetry is off, or the send fails, feedback exits zero and says which.
 
 Protect captures the paths this run must not change -- the developer's work in
 progress -- as path and digest, derived from the working tree rather than taken
@@ -390269,6 +391477,13 @@ report. Accept a path only when the run can show it did not write that path
 itself, and never one of the two files above: those exist to be rewritten by the
 run, so accepting one would record the run's own damage as the baseline.
 
+An env file is the exception, because the run asks the developer to write their
+model credential into it. Accept that with protect --accept-credential --path
+<path>. It takes nobody's word: it compares the variable names the baseline
+recorded with the names the file holds now, and refuses when a recorded
+credential is gone or empty. So the developer's own paste passes, and a step
+that rewrites .env and drops the project key still fails.
+
 Adding a feature to an app the developer already built needs the opposite
 record. The option lives in a file they wrote, so the run has to change it. The
 plan asks for that path, approving the plan grants it, and the grant is recorded
@@ -390276,12 +391491,23 @@ with protect --authorize --path <path> --reason <why> before any edit. The audit
 then reports the path instead of failing on it, and every later audit and the
 closing report name it with its reason. An authorization is refused once the
 path has moved, because consent taken afterwards cannot be told apart from a run
-clearing a failure it caused.
+clearing a failure it caused. Add --with-prior-change for the one case that rule
+had no answer for: the developer changed the file after the capture, and the run
+must change the same file. The earlier change is recorded as drift beside the
+consent, so both authors stay visible in the closing report.
+
+Consent belongs to the plan the developer approved. Once the run reports that
+plan with checkpoint --phase plan-written, --authorize is refused for every path
+the plan did not name: the developer approved the plan, not whatever the run
+reaches later. Where the run must change such a path, it asks the developer and
+records their answer with --unplanned, which marks the consent as taken outside
+the plan wherever it is printed. The flag is refused before the plan is
+reported, so it can never stand in for the plan's own approval.
 
 Checkpoint reports progress from inside a step, where the graph would
 otherwise say nothing between one prompt and the next. --phase takes one of:
-research-returned, starter-cloned, plan-written, build-validated,
-journey-attempted, repair-attempted. Pass --attempt <1-9>
+research-returned, starter-cloned, plan-written, container-surveyed,
+container-settled, build-validated, journey-attempted, repair-attempted. Pass --attempt <1-9>
 where the step loops, so a repair cycle can be counted.
 A refused checkpoint exits zero and prints the closed set. It is called from
 the middle of the longest step of a run, and a non-zero exit there reads as a
@@ -390317,19 +391543,28 @@ what they sent. Every refusal exits zero and leaves onboarding unaffected.
 `,
   verify: `Usage: copilotkit verify [--json] [--runtime-url <url>] [--round-trip]
                          [--expect-runtime <mode>] [--frontend-url <url>]
+                         [--expect-learning-container <id>]
 
 Check that this project's CopilotKit wiring works, and report what it found.
 
 Checks that a hosted project is selected, that a project API key is present and
 authenticates against Intelligence, that the CopilotKit runtime responds, that
-it declares at least one agent, that it accepts the origin a browser opens, and
-that the installed CopilotKit packages match the version it reports.
-Reports the runtime version, the agent framework in use, whether transcription
-is wired, the realtime gateway wiring, and the license state.
+it declares at least one agent, that it holds an Intelligence client and calls
+the same deployment the key was proven against, that it accepts the origin a
+browser opens, and that the installed CopilotKit packages match the version it
+reports. Reports the runtime version, the agent framework in use, whether
+transcription is wired, the realtime gateway wiring, and the license state.
 
 Every check reports PASS, FAIL, or UNKNOWN. UNKNOWN means the check could not
 run \u2014 it never means the check passed. Exits non-zero unless every check passed.
 
+The runtime's /info route reports that an Intelligence client was constructed.
+It does not report that the client reached anything, so no check here reads it
+as a successful call. Set INTELLIGENCE_API_URL in the env file the app loads:
+without it the runtime falls back to its own built-in host while this command
+proves the key against the host baked into this binary, and a valid key then
+gets 401 on every request.
+
 The report names the runtime URL it probed and where that URL came from. Nothing
 answering at a URL the project named is a FAIL; nothing answering at the assumed
 default is UNKNOWN, because an app running on a port this command never learned
@@ -390340,6 +391575,13 @@ the answer back from the thread, which is the only check here that proves the
 agent runs rather than that it is configured. That costs a model call and
 records a thread, so it is opt-in.
 
+A runtime mounted mode: "single-route" runs the request through its agent/run
+envelope, and the answer is read from the platform because that mount carries
+its thread routes inside the envelope rather than as REST paths this command
+can call. The report names which read answered: through the app, the answer
+belongs to the caller the app identified; from the platform, the run and its
+answer are proved and the end user they belonged to is not.
+
 With --expect-runtime oss, hosted project and credential checks do not apply.
 The command exits zero only when valid /info data declares the named agent,
 reports no Intelligence entitlement, and --round-trip --agent <id> passes.
@@ -390358,6 +391600,12 @@ Options:
                          to send a real CORS preflight when that origin differs
                          from the runtime's
   --expect-runtime <mode> Require intelligence (default) or oss runtime mode
+  --expect-learning-container <id>
+                          Require the round trip's thread to carry this
+                          Learning Container. Needs --round-trip --agent <id>.
+                          Read from the platform, so it answers for a runtime
+                          mounted mode: "single-route" too. A plan entitlement
+                          or an /info flag is not evidence.
   --round-trip           Also run the agent and read its answer back
   --agent <id>           Which declared agent to run, when there are several
   --timeout <seconds>    How long to wait for the answer (default: 90)
@@ -390653,6 +391901,7 @@ Actions:
   learning containers list          List Learning Containers (alias: ls)
   learning containers get <id>      Show one Learning Container (alias: show)
   learning containers create        Create a Learning Container
+  learning containers select        Pick one, or create one, in a terminal
   learning containers update <id>   Change a name or prompt context
   learning containers delete <id>   Delete an unused Learning Container
 
@@ -391245,7 +392494,7 @@ async function applyGlobalArgs(parsed) {
     setCliLogsVerbose2(true);
   }
 }
-async function runWhoami() {
+async function runWhoami(ctx) {
   const {
     clearAuthOnTerminalSessionInvalidation: clearAuthOnTerminalSessionInvalidation2,
     TERMINAL_SESSION_INVALID_MESSAGE: TERMINAL_SESSION_INVALID_MESSAGE2,
@@ -391265,17 +392514,20 @@ async function runWhoami() {
     if (clearAuthOnTerminalSessionInvalidation2(error98)) {
       process.stdout.write(`${TERMINAL_SESSION_INVALID_MESSAGE2}
 `);
+      ctx.reportFailure({ errorCode: "auth" });
       return;
     }
     if (error98 instanceof ApiClientError2 && error98.status > 0) {
       process.stdout.write(`${error98.message}
 `);
+      ctx.reportFailure({ errorCode: classifyError(error98) });
       return;
     }
     throw error98;
   }
   if (!session) {
     process.stdout.write("Session expired. Please run: copilotkit login\n");
+    ctx.reportFailure({ errorCode: "auth" });
     return;
   }
   process.stdout.write(`Email:        ${session.user.email}
@@ -391736,6 +392988,15 @@ function parseLearningContainersCommandArgs(argv) {
       ...parsed.values.cursor === void 0 ? {} : { cursor: parsed.values.cursor }
     };
   }
+  if (subcommand === "select") {
+    const parsed = parseArgs4({
+      args,
+      options: { json: { type: "boolean" } },
+      strict: true,
+      allowPositionals: false
+    });
+    return { action: "select", json: parsed.values.json === true };
+  }
   if (subcommand === "get") {
     const parsed = parseArgs4({
       args,
@@ -391974,7 +393235,7 @@ function learningParseFailureSubcommand(argv) {
   const resource = argv[0];
   const action = argv[1];
   if (resource === "containers") {
-    return action === "list" || action === "get" || action === "show" || action === "create" || action === "update" || action === "delete" ? `containers.${action === "show" ? "get" : action}` : "containers.invalid";
+    return action === "list" || action === "get" || action === "show" || action === "create" || action === "select" || action === "update" || action === "delete" ? `containers.${action === "show" ? "get" : action}` : "containers.invalid";
   }
   if (resource === "insights" || resource === "skills") {
     return action === "list" || action === "ls" ? `${resource}.list` : `${resource}.invalid`;
@@ -392078,10 +393339,10 @@ ${helpTextForTopic("learning")}`
         createLearningContainersCommandDependencies: createLearningContainersCommandDependencies2,
         runLearningContainersCommand: runLearningContainersCommand2
       } = await init_learning_containers().then(() => learning_containers_exports);
-      await runLearningContainersCommand2(
-        command2,
-        createLearningContainersCommandDependencies2()
-      );
+      await runLearningContainersCommand2(command2, {
+        ...createLearningContainersCommandDependencies2(),
+        telemetry: { setProperties: telemetryContext.setProperties }
+      });
     }
   );
 }
@@ -392173,6 +393434,7 @@ async function runVerifyCommand(argv) {
     options: {
       agent: { type: "string" },
       "expect-runtime": { type: "string" },
+      "expect-learning-container": { type: "string" },
       "frontend-url": { type: "string" },
       header: { multiple: true, type: "string" },
       json: { type: "boolean" },
@@ -392226,17 +393488,44 @@ async function runVerifyCommand(argv) {
     await exitWithFlush(1);
   }
   const agent = parsed.values["agent"];
+  const expectLearningContainer = parsed.values["expect-learning-container"];
+  if (expectLearningContainer !== void 0 && !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(expectLearningContainer)) {
+    process.stderr.write(
+      "Error: --expect-learning-container expects 1-64 lowercase letters, numbers, and single hyphens.\n"
+    );
+    await exitWithFlush(1);
+  }
   const { runVerify: runVerify2 } = await Promise.resolve().then(() => (init_verify(), verify_exports));
-  await runVerify2({
-    json: parsed.values["json"] === true,
-    ...agent === void 0 ? {} : { agent },
-    ...expectedRuntime === void 0 ? {} : { expectRuntime: expectedRuntime },
-    ...headers === void 0 || Object.keys(headers).length === 0 ? {} : { headers },
-    ...frontendUrl === void 0 ? {} : { frontendUrl },
-    ...parsed.values["round-trip"] === true ? { roundTrip: true } : {},
-    ...runtimeUrl === void 0 ? {} : { runtimeUrl },
-    ...timeoutSeconds === void 0 ? {} : { timeoutMs: Number(timeoutSeconds) * 1e3 }
-  });
+  await runVerify2(
+    {
+      json: parsed.values["json"] === true,
+      ...agent === void 0 ? {} : { agent },
+      ...expectLearningContainer === void 0 ? {} : { expectLearningContainer },
+      ...expectedRuntime === void 0 ? {} : { expectRuntime: expectedRuntime },
+      ...headers === void 0 || Object.keys(headers).length === 0 ? {} : { headers },
+      ...frontendUrl === void 0 ? {} : { frontendUrl },
+      ...parsed.values["round-trip"] === true ? { roundTrip: true } : {},
+      ...runtimeUrl === void 0 ? {} : { runtimeUrl },
+      ...timeoutSeconds === void 0 ? {} : { timeoutMs: Number(timeoutSeconds) * 1e3 }
+    },
+    {
+      // A point event rather than a property on the command's own lifecycle
+      // event. `verify` is dispatched as `auto`, which owns the bookend and does
+      // not hand the runner its telemetry context, and the outcome is worth its
+      // own row: the lifecycle event answers "did the command run", this answers
+      // "did Learning prove out for this project".
+      recordLearningContainerCheck: ({ outcome }) => {
+        recordTelemetryEvent({
+          event: "cli.verify.learning_container_checked",
+          properties: {
+            command: "verify",
+            learning_check_outcome: outcome,
+            ...currentOnboardingRunProperties()
+          }
+        });
+      }
+    }
+  );
 }
 async function runTypegenCommand(argv) {
   const parsed = parseArgs4({
@@ -392498,6 +393787,10 @@ async function runInitCommand(invokedAs, argv) {
     await runInit2(flags, callbacks);
   });
 }
+var UNWRAPPED_TELEMETRY_CONTEXT = {
+  setProperties: () => void 0,
+  reportFailure: () => void 0
+};
 var ONBOARD_SUBCOMMANDS2 = [
   "audit",
   "checkpoint",
@@ -392505,6 +393798,7 @@ var ONBOARD_SUBCOMMANDS2 = [
   "complete",
   "feedback",
   "friction",
+  "identify",
   "proof",
   "protect",
   "read",
@@ -392567,8 +393861,8 @@ var COMMAND_TABLE = {
   whoami: {
     kind: "auto",
     command: "whoami",
-    run: async () => {
-      await runWhoami();
+    run: async (_argv, _token, ctx) => {
+      await runWhoami(ctx);
     }
   },
   docs: {
@@ -392731,13 +394025,13 @@ async function main(rawArgv = process.argv.slice(2)) {
         command: entry.command,
         ...subcommand === void 0 ? {} : { subcommand }
       },
-      async () => {
-        await entry.run(commandArgv, command2);
+      async (ctx) => {
+        await entry.run(commandArgv, command2, ctx);
       }
     );
     return;
   }
-  await entry.run(commandArgv, command2);
+  await entry.run(commandArgv, command2, UNWRAPPED_TELEMETRY_CONTEXT);
 }
 function resolveRealPath(candidatePath) {
   const absolutePath = path44.resolve(candidatePath);