Method run

src/agent/loop.ts:903–2203

(
    messages: Message[],
    sessionId: string,
    options: AgentOptions,
  )

                  const { result } = await evalSkillMd(this.cwd, candidate.skillMd, { noCache: true });
                  if (result) {
                    const fsmod = await import('fs');
                    const pathmod = await import('path');
                    const file = pathmod.join(candidatesDir(), candidate.name, 'SKILL.md');
                    const updated = upsertEvalSection(candidate.skillMd, formatEvalSection(result, skillContentHash(candidate.skillMd)));
                    await fsmod.promises.writeFile(file, updated, 'utf-8');
                    await recordLearningEvent({ event: 'eval', name: candidate.name, evalStatus: result.status });
                    yield { type: 'notice', data: { message: `🧪 Auto-eval of "${candidate.name}": ${result.status}.` } };
                  }
                } catch (e: any) {
                  logger.debug('Auto-eval after capture skipped', { err: e?.message });
                }
              }
            } else {
              logger.debug('Skill capture skipped', { reason: elig.reason });
            }
          } catch (e: any) {
            logger.debug('Skill capture skipped (error)', { err: e?.message });
          }
        }
        // ── Code-graph skill SUGGESTION ── Whenever nothing was captured (learning off, OR on but
        // the task wasn't capture-eligible), still nudge the user when the work looks like a REUSABLE
        // pattern, judged from the SHAPE of the change via the code graph (focused + cohesive +
        // multi-file). The judgment a code-graph-less agent can't make. A gentle one-liner; off via
        // learning.suggestSkills:false; conservative (only fires for real patterns), never duplicative.
        if (!capturedThisRun && learningCfg?.suggestSkills !== false && changedFiles.length >= 2) {
          try {
            const { suggestSkillFromSession, commonArea } = await import('../skills/learning/skill-suggest.js');
            const area = commonArea(changedFiles);
            const inArea = changedFiles.filter(f => f.split('/').slice(0, 2).join('/') === area).length;
            const cohesion = changedFiles.length ? inArea / changedFiles.length : 0;
            const s = suggestSkillFromSession({ prompt: String(firstUserMsg), changedFiles, cohesion });
            if (s.worth) {
              const how = learningCfg?.enabled
                ? `run \`qodex skill candidates\` to capture it`
                : `enable \`learning.enabled\` to auto-capture skills like this`;
              yield { type: 'notice', data: { message: `💡 This looks reusable ("${s.proposedName}") — ${s.reason} ${how}.` } };
            }
          } catch { /* best-effort */ }
        }
      } else if (reachedFinal && !merged) {
        if (!finishResult.merged && finishResult.reason === 'empty') {
          yield { type: 'notice', data: { message: '🔒 Sandbox: nothing to merge (no committed changes)' } };
        } else {
          // Real merge failure (conflict/error): the work is NOT lost — it's still
          // on the sandbox branch. Tell the user distinctly so they don't think
          // their changes simply vanished.
          const reason = !finishResult.merged ? finishResult.reason : 'error';
          const errSuffix = (!finishResult.merged && finishResult.error) ? ` (${finishResult.error})` : '';
          const branchSuffix = sandboxBranch ? ` Your work is preserved on branch '${sandboxBranch}'.` : ' Your work is preserved on the sandbox branch.';
          yield { type: 'notice', data: { message: `🔒 Sandbox: FAILED to merge your changes onto your branch (${reason})${errSuffix}.${branchSuffix}` } };
        }
      } else {
        yield { type: 'notice', data: { message: '🔒 Sandbox: task did not complete — your branch was left untouched' } };
      }

      // Ground-truth trust receipt for unattended/scheduled runs. QodeX writes it from ITS OWN
      // signals — the git diff + the checkers it actually ran — so the model can't fabricate it.
      await this.writeRunReceipt({ reachedFinal, merged, finalContent, changedFiles, signal: options.signal });