great-cto 3.62.2 → 3.63.0

package/board/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "great-cto",
   "description": "You already have the agent. This is everything around it. great_cto runs Claude Code as a pipeline of 72 specialist agents \u2014 an independent model checks each stage before the next builds on it, spending caps refuse rather than warn, and three decisions stay yours: what gets built, how, and whether it ships.",
-  "version": "3.62.2",
+  "version": "3.63.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

package/board/packages/board/lib/work.mjs

@@ -16,6 +16,30 @@ const date = v => typeof v === 'string' && Number.isFinite(Date.parse(v)) ? v :
 const RUN_PHASE = { ready: 'accepted', 'awaiting-gate': 'needs_decision',
   'awaiting-release': 'needs_decision', blocked: 'blocked', 'manual-action': 'blocked' };
 
+/** Recorded observations are not current-tree verification or gate authority. */
+function evidenceSections(entry) {
+  const events = entry.inspector?.state === 'recorded' ? entry.inspector.events.length : 0;
+  const verdicts = entry.evidence.filter(e => e.kind === 'verdict');
+  const reported = verdicts.filter(e => e.verifierReported === true).length;
+  const publication = entry.publication;
+  const published = ['prepared', 'pushed', 'pr-linked'].includes(publication?.state);
+  return [
+    { id: 'execution', label: 'Execution', state: events ? 'recorded' : 'unknown',
+      detail: events ? `${events} linked activity events in the bounded window. Liveness and task acceptance are not established.${entry.inspector.partial ? ' The activity window is incomplete.' : ''}`
+        : entry.inspector?.reason || 'No explicitly linked execution events are available.' },
+    { id: 'checks', label: 'Checks', state: verdicts.length ? 'recorded' : 'unknown',
+      detail: verdicts.length ? `In this bounded view: ${verdicts.length} role verdict records; ${reported} verifier-success reports. Test counts and current input bindings are not available in this projection.`
+        : 'No task-linked check records are available. Completed roles do not establish verification.' },
+    { id: 'review', label: 'Review', state: 'unknown',
+      detail: 'No task-bound review input digest and reviewer provenance are available. Role verdicts alone do not establish independent review.' },
+    { id: 'publication', label: 'Publication', state: published ? 'recorded' : 'unknown',
+      detail: published ? `Publication state: ${publication.state}${/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(publication.head || '') ? `; recorded head: ${publication.head}` : ''}. This does not establish merge, release or deployment.`
+        : 'No task-linked publication record is available.' },
+    { id: 'runtime', label: 'Runtime', state: 'unknown',
+      detail: 'No task-linked runtime probe is available. Release records and successful process exits do not establish deployment health.' },
+  ];
+}
+
 export function projectWork({ projectId, issues = [], codex = { state: 'absent', runs: [] },
   tasks = [], sessions = [], sources = [], activity = { state: 'none', events: [] }, observedAt = new Date().toISOString() }) {
   const entries = [];
@@ -78,7 +102,8 @@ export function projectWork({ projectId, issues = [], codex = { state: 'absent',
       host: t.host, phase: t.phase, nativeState: run?.nativeState || t.phase,
       terminal: ['cancelled', 'completed'].includes(t.phase), updatedAt: t.updatedAt, outcome: t.outcome?.state === 'completed' ? `${t.intent || 'delivery'} outcome explicitly completed` : null, reason: t.reason,
       intent: t.intent || 'delivery', stage: t.stage || null, taskOutcome: t.outcome || null,
-      decisions: decisionCapabilities(t).map(d => ({ ...d, id: d.decisionId, label: d.label || 'Host decision' })), evidence: (t.evidence || []).map(e => ({ kind: 'verdict', label: `${e.role}: ${e.verdict || 'not recorded'}` })),
+      decisions: decisionCapabilities(t).map(d => ({ ...d, id: d.decisionId, label: d.label || 'Host decision' })), evidence: (t.evidence || []).slice(0, 200).filter(e => e && text(e.role)).map(e => ({ kind: 'verdict',
+        label: `${e.role.slice(0, 80)}: ${text(e.verdict)?.slice(0, 80) || 'not recorded'}`, verifierReported: typeof e.verified === 'boolean' ? e.verified : null })),
       release: run?.release || null, revision: t.revision, metrics: t.metrics,
       inspector: taskInspector([...t.links.runs, ...t.links.sessions], activity),
       publication: t.publication || null,
@@ -90,6 +115,7 @@ export function projectWork({ projectId, issues = [], codex = { state: 'absent',
       command: approveCommand || (enabled ? `great-cto resume --task ${t.taskId} --host ${t.host} --revision ${t.revision}` : null),
     });
   }
+  for (const entry of entries) entry.evidenceSections = evidenceSections(entry);
   entries.sort((a, b) => (a.terminal - b.terminal) || (b.decisions.length - a.decisions.length)
     || (Date.parse(b.updatedAt || '') || 0) - (Date.parse(a.updatedAt || '') || 0) || a.key.localeCompare(b.key));
   const health = sources.some(s => ['degraded', 'unavailable'].includes(s.health)) ? 'degraded' : 'current';

package/board/packages/board/public/assets/work-view.js

@@ -28,6 +28,7 @@
           + action + (e.command ? `<pre>${esc(e.command)}</pre>` : '')
           + (!cap && e.capabilities[0]?.reason ? `<p>${esc(e.capabilities[0].reason)}</p>` : '')
           + renderInspector(e.inspector)
+          + renderEvidence(e.evidenceSections)
           + (e.publicationPreview ? `<label>Publication paths (comma-separated) <input data-publication-allow="${esc(e.key)}" value="${esc(e.publicationAllow || '')}" placeholder="src,tests"></label><button type="button" class="gate-btn" data-work-key="${esc(e.key)}" data-work-action="preview_publication">Preview draft PR publication</button><div data-publication-preview="${esc(e.key)}"></div>` : '')
           + (e.publication ? `<p>PR publication: ${esc(e.publication.state)} · ${esc(e.publication.head || '')}</p>`
             + (typeof e.publication.url === 'string' && /^https:\/\/github\.com\/[A-Za-z0-9_-]+\/[A-Za-z0-9_.-]+\/pull\/[1-9][0-9]*$/.test(e.publication.url) ? `<a href="${esc(e.publication.url)}" target="_blank" rel="noopener noreferrer">Open draft PR result</a>` : '')
@@ -56,6 +57,12 @@
         + (e.durationMs !== null ? ` · ${esc(e.durationMs)} ms` : '') + '</li>').join('') + '</ol>' : '')
       + '</details>';
   }
+  function renderEvidence(sections) {
+    if (!Array.isArray(sections)) return '';
+    return '<details data-work-detail="evidence"><summary>Task evidence · read-only</summary>'
+      + '<p>Recorded means an observation exists, not that the current code passed a gate. Unknown means evidence is unavailable, not zero or success.</p>'
+      + '<dl>' + sections.map(s => `<dt>${esc(s.label)} · ${s.state === 'recorded' ? 'Recorded' : 'Unknown'}</dt><dd>${esc(s.detail)}</dd>`).join('') + '</dl></details>';
+  }
   function publicationCommand(preview) {
     const confirmation = preview.confirmation || { expectedRevision: preview.revision, approval: preview.approval };
     if (!/^[0-9a-f-]{36}$/.test(preview.taskId || '') || !Number.isInteger(confirmation.expectedRevision) || confirmation.expectedRevision < 1

package/board/packages/board/public/index.html

@@ -3378,6 +3378,8 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .work-card h2 { font-size: var(--fs-title-s); }
 .work-card p, #work-compose p { margin: 8px 0; font-size: var(--fs-body); }
 .work-meta { color: var(--text2); font-size: var(--fs-caption); }
+.work-card [data-work-detail="evidence"] dt { margin-top: 12px; font-weight: 600; }
+.work-card [data-work-detail="evidence"] dd { margin: 4px 0 12px; color: var(--text2); font-size: var(--fs-body); overflow-wrap: anywhere; }
 .work-warning { color: var(--absent-warn-fg); background: var(--bg-card); border: 1px solid var(--absent-warn-fg); padding: 12px; }
 .work-page pre { font-weight: 400; white-space: pre-wrap; overflow-wrap: anywhere; margin: 12px 0; }
 #work-compose textarea, #work-compose input, #work-compose select { display: block; width: 100%; margin: 8px 0 12px; padding: 8px; background: var(--bg-muted); color: var(--text); border: 1px solid var(--border-strong); border-radius: 4px; }
@@ -4224,8 +4226,12 @@ function reviewerCells(t) {
   if (!so || so.state === 'not-run') codex = `<span class="abs" title="${esc(so?.why || 'second opinion not run')}">— Codex</span>`;
   else if (so.state === 'unmeasured') codex = `<span class="abs" title="${esc(so.why)}">· Codex</span>`;
   else if (so.state === 'unreadable') codex = `<span class="abs" title="${esc(so.why)}">! Codex</span>`;
-  else if (so.verdict === 'BLOCK') codex = `<span title="Codex BLOCK on ${esc((so.sha || '').slice(0, 8))} — ${esc(String(so.p0 ?? '?'))}×P0"><span class="dot bad"></span> Codex ✗</span>`;
-  else codex = `<span title="Codex ${esc(so.verdict || 'PASS')} on ${esc((so.sha || '').slice(0, 8))}"><span class="dot ok"></span> Codex ✓</span>`;
+  else if (so.state === 'unreviewable') codex = `<span class="abs" title="${esc(so.why)}">! Codex</span>`;
+  else if (so.state === 'ok' && so.verdict === 'BLOCK') codex = `<span title="Codex BLOCK on ${esc((so.sha || '').slice(0, 8))} — ${esc(String(so.p0 ?? '?'))}×P0"><span class="dot bad"></span> Codex ✗</span>`;
+  // A tick only for a review that passed — never as the fallback for a state
+  // this renderer does not know (an `unreviewable` diff once fell through to ✓).
+  else if (so.state === 'ok' && so.verdict === 'PASS') codex = `<span title="Codex PASS on ${esc((so.sha || '').slice(0, 8))}"><span class="dot ok"></span> Codex ✓</span>`;
+  else codex = `<span class="abs" title="${esc(so.why || `second opinion: ${so.state || 'unknown'}, verdict ${so.verdict ?? 'none'}`)}">? Codex</span>`;
   return `<span class="gate-review">${claude}${codex}</span>`;
 }
 function gateChip(t) {

package/board/scripts/lib/cross-model-review.mjs

@@ -1,9 +1,9 @@
 // scripts/lib/cross-model-review.mjs — cross-model adversarial review (architect-loop R3).
 //
-// great_cto's reviews are Claude-on-Claude → same-model blind spots. This red-teams
-// the diff with a DIFFERENT model via OpenRouter (default openai/gpt-5), flagging
+// Review the supplied diff through the configured second-opinion provider, flagging
 // ONLY correctness / requirement / invariant gaps with file:line — no style. The
 // code-reviewer agent merges these with its own findings for high-stakes changes.
+// Provider/model metadata alone does not establish cross-model independence.
 //
 // Pure (buildReviewPrompt / parseFindings / pickReviewerModel) is unit-tested with
 // no network; the CLI does the live OpenRouter call.
@@ -21,6 +21,7 @@ import { resolveSecondOpinion, codexReview } from './second-opinion.mjs';
 import { principalError } from './provider-exhaustion.mjs';
 import { existsSync, appendFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { reviewInputBinding, parseLegacyReview } from './review-contract.mjs';
 
 /**
  * Exit codes. The first version had two: 0 for PASS and 1 for everything else —
@@ -64,13 +65,14 @@ export function decideProvider({ argv = [], projectMd = '', codex = null, env =
  * written before this field existed, and any caller that doesn't supply them,
  * still serializes to the same shape a reader already knows how to parse.
  */
-export function reviewLogLine({ provider, model, state, verdict, findings, cost, source, error_kind, resets_at, sha, dirty }) {
+export function reviewLogLine({ provider, model, state, verdict, findings, cost, source, error_kind, resets_at, sha, dirty, review_input }) {
   return JSON.stringify({
     ts: new Date().toISOString(), provider, model: model ?? null, state, verdict: verdict ?? null,
     error_kind: error_kind ?? null, resets_at: resets_at ?? null,
     findings: Array.isArray(findings) ? findings.length : null,
     p0: Array.isArray(findings) ? findings.filter((f) => f.severity === 'P0').length : null,
     cost: cost ?? null, source, sha: sha ?? null, dirty: dirty ?? null,
+    review_input: review_input ?? null,
   });
 }
 
@@ -84,8 +86,8 @@ export function pickReviewerModel(env = process.env) {
 /** Build the red-team prompt. Calibrated: correctness/invariant only, file:line, no style. */
 export function buildReviewPrompt({ diff, spec }) {
   const system =
-    'You are an adversarial code reviewer from a DIFFERENT model family than the author. ' +
-    'Your job is to catch what a same-model reviewer would miss. Review ONLY for: ' +
+    'You are an adversarial code reviewer. Do not assume your model family differs from the author. ' +
+    'Review ONLY for: ' +
     'correctness bugs, violated requirements, broken invariants, security holes, data loss. ' +
     'Do NOT report style, naming, or preferences. Ground every finding in the diff with file:line. ' +
     'Default to silence over a weak finding. ' +
@@ -102,32 +104,7 @@ export function buildReviewPrompt({ diff, spec }) {
 
 /** Parse the model's findings + verdict. */
 export function parseFindings(text) {
-  const findings = [];
-  let verdict = null;
-  for (const raw of String(text).split('\n')) {
-    const line = raw.trim();
-    const v = line.match(/^VERDICT:\s*(BLOCK|PASS)/i);
-    if (v) { verdict = v[1].toUpperCase(); continue; }
-    // <file>:<line> | <SEV> | <issue>
-    const m = line.match(/^(.+?):(\d+)\s*\|\s*(P[012])\s*\|\s*(.+)$/i);
-    if (m) findings.push({ file: m[1].trim(), line: parseInt(m[2], 10), severity: m[3].toUpperCase(), issue: m[4].trim() });
-  }
-  // Derive a verdict only in the direction that is safe to be wrong about.
-  //
-  // This used to answer PASS whenever no `VERDICT:` line was found and no P0
-  // was parsed. But an empty body, a refusal, a reply in some other format and
-  // a model that genuinely said "looks clean" are the SAME input here — all
-  // four leave `verdict` null and `findings` without a P0. Reading any of them
-  // as PASS reads all of them as PASS, so a review that could not be read
-  // became a review that approved, and the Stop hook downstream ended the turn
-  // on it.
-  //
-  // A derivation that BLOCKS costs a second look. A derivation that PASSES
-  // spends the guarantee. So: a P0 with no verdict line still blocks; nothing
-  // else is turned into a verdict, and `null` means the model never reached
-  // one. Callers must treat null as "no verdict", never as a pass.
-  if (!verdict && findings.some(f => f.severity === 'P0')) verdict = 'BLOCK';
-  return { findings, verdict };
+  return parseLegacyReview(text);
 }
 
 // ── CLI ───────────────────────────────────────────────────────────────────────
@@ -178,8 +155,9 @@ async function main(argv) {
   const projectMd = existsSync(mdPath) ? readFileSync(mdPath, 'utf8') : '';
   const decision = decideProvider({ argv, projectMd });
   const identity = gitIdentity(root);
+  let review_input = null;
   const logPath = join(root, '.great_cto', 'cross-review.log');
-  const log = (rec) => { try { mkdirSync(join(root, '.great_cto'), { recursive: true }); appendFileSync(logPath, reviewLogLine({ ...rec, source: decision.source, sha: identity.sha, dirty: identity.dirty }) + '\n'); } catch { /* the log is evidence, not a gate */ } };
+  const log = (rec) => { try { mkdirSync(join(root, '.great_cto'), { recursive: true }); appendFileSync(logPath, reviewLogLine({ ...rec, source: decision.source, sha: identity.sha, dirty: identity.dirty, review_input }) + '\n'); } catch { /* the log is evidence, not a gate */ } };
 
   // Anything that is not a reviewer reviewing exits SKIPPED — not PASS, and not
   // the BLOCK code either. The line says why, and the log keeps it.
@@ -190,10 +168,17 @@ async function main(argv) {
   }
 
   const diff = diffPath === '-' ? readFileSync(0, 'utf8') : readFileSync(diffPath, 'utf8');
-  if (!diff.trim()) { console.log('cross-model-review: empty diff, nothing to review.'); process.exit(EXIT.PASS); }
   const specFile = readArg(argv, '--spec');
-  const spec = specFile ? readFileSync(specFile, 'utf8').slice(0, 4000) : null;
-  const prompt = buildReviewPrompt({ diff: diff.slice(0, 24000), spec });
+  const spec = specFile ? readFileSync(specFile, 'utf8') : null;
+  review_input = reviewInputBinding({ diff, spec, sourceSha: identity.sha });
+  // A truncated prefix is not a review of the full input. Never silently approve it.
+  if (!diff.trim() || diff.length > 24000 || (spec !== null && spec.length > 4000)) {
+    const error_kind = !diff.trim() ? 'empty-diff' : 'input-too-large';
+    console.log(`cross-model-review: SKIPPED (${error_kind}) — complete review input required.`);
+    log({ provider: decision.provider, state: 'unreadable', verdict: null, findings: null, cost: null, error_kind });
+    process.exit(EXIT.SKIPPED);
+  }
+  const prompt = buildReviewPrompt({ diff, spec });
 
   let res;
   if (decision.provider === 'codex') {

package/board/scripts/lib/review-contract.mjs

@@ -0,0 +1,66 @@
+/** Host-neutral review evidence. Pure data contract, never gate authority. */
+import { createHash } from 'node:crypto';
+
+export const REVIEW_CONTRACT_VERSION = 1;
+const hash = value => createHash('sha256').update(value).digest('hex');
+const digest = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+
+/** Bind the exact submitted UTF-8 inputs and caller context, without storing bodies. */
+export function reviewInputBinding({ diff, spec = null, taskId = null, sourceSha = null } = {}) {
+  if (typeof diff !== 'string' || (spec !== null && typeof spec !== 'string')
+    || (taskId !== null && (typeof taskId !== 'string' || taskId.length > 256))
+    || (sourceSha !== null && !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sourceSha))) throw Error('invalid review input');
+  const binding = { version: REVIEW_CONTRACT_VERSION, taskId, sourceSha,
+    diffSha256: hash(diff), diffBytes: Buffer.byteLength(diff),
+    specSha256: spec === null ? null : hash(spec), specBytes: spec === null ? null : Buffer.byteLength(spec) };
+  return { ...binding, inputDigest: hash(JSON.stringify(binding)) };
+}
+
+/** Normalize trusted adapter metadata plus untrusted reviewer output. */
+export function normalizeReviewResult(options = {}) {
+  const { inputDigest, expectedInputDigest, reviewer,
+    state = 'ok', verdict = null, findings = null } = options && typeof options === 'object' ? options : {};
+  const identity = { host: typeof reviewer?.host === 'string' ? reviewer.host : null,
+    model: typeof reviewer?.model === 'string' ? reviewer.model : null };
+  const unknown = reason => ({ version: REVIEW_CONTRACT_VERSION, state: 'not-checked',
+    verdict: null, reason, inputDigest: digest(inputDigest) ? inputDigest : null,
+    reviewer: identity, findings: [] });
+  if (!digest(inputDigest) || !digest(expectedInputDigest) || inputDigest !== expectedInputDigest) return unknown('input-mismatch');
+  if (state !== 'ok') return unknown('adapter-unavailable');
+  if (!['PASS', 'BLOCK'].includes(verdict) || !Array.isArray(findings) || findings.length > 200) return unknown('invalid-result');
+  const valid = Array.from(findings).every(f => f && typeof f === 'object'
+    && typeof f.file === 'string' && f.file.length > 0 && f.file.length <= 1024
+    && !/^[\\/]|^[A-Za-z]:|[\\\x00-\x1f]/.test(f.file)
+    && f.file.split('/').every(part => part && part !== '.' && part !== '..')
+    && Number.isSafeInteger(f.line) && f.line > 0
+    && ['P0', 'P1', 'P2'].includes(f.severity)
+    && typeof f.issue === 'string' && f.issue.trim().length > 0 && f.issue.length <= 4000);
+  if (!valid) return unknown('invalid-findings');
+  const result = findings.map(({ file, line, severity, issue }) => ({ file, line, severity, issue }));
+  return { version: REVIEW_CONTRACT_VERSION, state: 'checked',
+    verdict: result.some(f => f.severity === 'P0') ? 'BLOCK' : verdict,
+    reason: result.some(f => f.severity === 'P0') && verdict === 'PASS' ? 'p0-overrides-pass' : null,
+    inputDigest, reviewer: identity, findings: result };
+}
+
+/** Legacy line protocol adapter; ambiguity never becomes approval. */
+export function parseLegacyReview(text) {
+  if (typeof text !== 'string' || Buffer.byteLength(text) > 1024 * 1024) return { findings: [], verdict: null };
+  const findings = [], verdicts = []; let malformed = false;
+  for (const raw of text.split('\n')) {
+    const line = raw.trim(), v = line.match(/^VERDICT:\s*(BLOCK|PASS)$/i);
+    if (v) { verdicts.push(v[1].toUpperCase()); continue; }
+    const m = line.match(/^(.+?):(\d+)\s*\|\s*(P[012])\s*\|\s*(.+)$/i);
+    // Protocol keywords inside a complete finding are diagnostic text, not verdict lines.
+    if (m) { findings.push({ file: m[1].trim(), line: Number(m[2]), severity: m[3].toUpperCase(), issue: m[4].trim() }); continue; }
+    if (/\bVERDICT\b/i.test(line) || /\|\s*P\d/i.test(line) || /^.+?:[^|]*\|/.test(line) || /\|[^|]*\|/.test(line)) malformed = true;
+  }
+  // No verdict may conservatively block a concrete P0, never pass.
+  const verdict = malformed || verdicts.length > 1 ? null
+    : verdicts[0] || (findings.some(f => f.severity === 'P0') ? 'BLOCK' : null);
+  const pin = hash('legacy-adapter');
+  const normalized = normalizeReviewResult({ inputDigest: pin, expectedInputDigest: pin, verdict, findings });
+  // Preserve valid parsed findings for diagnostics when the verdict is missing.
+  const validation = normalizeReviewResult({ inputDigest: pin, expectedInputDigest: pin, verdict: 'BLOCK', findings });
+  return { findings: validation.findings, verdict: normalized.verdict };
+}

package/board/scripts/lib/second-opinion-for-tree.mjs

@@ -12,6 +12,8 @@
 //   not-run    — no second opinion is declared (including a deliberate `none`)
 //   unmeasured — declared, but nothing has reviewed THIS tree
 //   unreadable — lines exist and none can be paired (they predate the join key)
+//   unreviewable — the review refused this tree's input (empty, or over its size
+//                  limit) — no reviewer read it, and re-running will not change that
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
@@ -48,6 +50,15 @@ export function secondOpinionForTree(c) {
   const noVerdict = rows.filter((r) => joins(r) && r.state === 'unreadable');
   if (noVerdict.length) {
     const r = noVerdict[noVerdict.length - 1];
+    // A refusal before any reviewer was asked (ADR-030: no review of a truncated
+    // prefix) is not an answer. Saying "answered without a verdict" sent the
+    // agent to re-run a review that refuses the same input every time.
+    if (r.error_kind === 'input-too-large' || r.error_kind === 'empty-diff') {
+      return { ...base, state: 'unreviewable', error_kind: r.error_kind, sha: r.sha, ts: r.ts ?? null,
+        why: r.error_kind === 'empty-diff'
+          ? 'the diff was empty — there was nothing to review'
+          : `the diff is too large for ${tool} to review whole (over 24 000 characters of diff or 4 000 of spec) — no reviewer read it` };
+    }
     return { ...base, state: 'unreadable', sha: r.sha, ts: r.ts ?? null,
       why: `${tool} answered for this tree and the answer carries no verdict — it is not a pass` };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "3.62.2",
+  "version": "3.63.0",
   "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
   "keywords": [
     "claude-code",