@starci/skills 1.1.0

package/operators/content-generate/validate.mjs

@@ -0,0 +1,196 @@
+// content.generate's own law over one branch, on top of the shared step check: the brief is the measure
+// of everything after it, and the receipt restates it; every declared edition exists once per language
+// and covers the whole published outcome set; the image stage produces something only when stageModes
+// turns it on, and a stage that stayed off is recorded rather than merely absent; every declared track
+// builds and is exercised by the executable check inside the iteration bound, whose contract
+// fingerprint did not move; and the review is a fresh execution that produced none of the artifacts,
+// received all of them, received no producer rationale, approves only at or above the published
+// minimum with no open error finding, and spends no more rounds than maxReviewRounds.
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { validateStep } from '../../scripts/validate-step.mjs';
+import { tableUnder } from '../../scripts/validate-response.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const MINIMUM_SCORE = 85;
+const empty = (v) => v === undefined || v === null || v === '' || v === '—';
+const fields = (rows) => Object.fromEntries((rows ?? []).map(([k, v]) => [k, v]));
+const sameSet = (left, right) => { const a = new Set(left); const b = new Set(right); return a.size === b.size && [...a].every((item) => b.has(item)); };
+const list = (v) => (Array.isArray(v) ? v : String(v ?? '').split(',').map((s) => s.trim()).filter(Boolean));
+const listed = (value) => (value === undefined ? [] : Array.isArray(value) ? value : [value]);
+// An edition is filed as article.<language>.md and a track as track.<language>.<extension>, so the
+// language is everything between the prefix and the extension.
+const languageOf = (file, prefix) => {
+  const parts = String(file).split('/').pop().split('.');
+  if (parts.length < 3 || parts[0] !== prefix) return null;
+  return parts.slice(1, -1).join('.');
+};
+
+export async function validateContentStep(branchDir, root = ROOT) {
+  const base = await validateStep(root, branchDir);
+  const errors = [...base.errors];
+  const { response, requirements = {}, present = new Set() } = base;
+  if (!response || response.operatorId !== 'content.generate') return { errors };
+  const has = (f) => existsSync(path.join(branchDir, f));
+  const read = (f) => readFile(path.join(branchDir, f), 'utf8');
+
+  const naturalLanguages = list(requirements.naturalLanguages);
+  const implementationLanguages = list(requirements.implementationLanguages);
+  const imageOn = (requirements.stageModes ?? {}).image === 'on';
+  const maxE2eIterations = Number(requirements.maxE2eIterations ?? 2);
+  const maxReviewRounds = Number(requirements.maxReviewRounds ?? 2);
+  if (naturalLanguages.length === 0) errors.push('request.json: a unit is written in at least one natural language');
+  if (new Set(naturalLanguages).size !== naturalLanguages.length) errors.push('request.json: naturalLanguages must not repeat a language');
+  if (new Set(implementationLanguages).size !== implementationLanguages.length) errors.push('request.json: implementationLanguages must not repeat a language');
+  const commandLanguages = (Array.isArray(requirements.commands) ? requirements.commands : []).map((c) => c.language);
+  if (new Set(commandLanguages).size !== commandLanguages.length) errors.push('request.json: commands must not name a language twice');
+  if (!sameSet(commandLanguages, implementationLanguages)) errors.push('request.json: commands must cover exactly the declared implementationLanguages, and nothing else');
+
+  // A blocked branch carries no unit at all.
+  if (response.status === 'blocked' && (present.has('content-generation-receipt') || present.has('content-brief') || present.has('e2e'))) {
+    errors.push('response/response.json: a blocked branch carries no unit');
+  }
+
+  const articleFiles = listed(response.fields?.article);
+  const trackFiles = listed(response.fields?.track);
+  const imageFiles = listed(response.fields?.image);
+  const promptFiles = listed(response.fields?.['image-prompt']);
+  const articleLanguages = articleFiles.map((f) => languageOf(f, 'article'));
+  const trackLanguages = trackFiles.map((f) => languageOf(f, 'track'));
+  if (response.status !== 'blocked') {
+    if (new Set(articleLanguages).size !== articleLanguages.length) errors.push('response/response.json: a language cannot have two article editions');
+    if (articleFiles.length && !sameSet(articleLanguages, naturalLanguages)) errors.push('response/response.json: the article editions must cover exactly the declared natural languages');
+    if (!sameSet(trackLanguages, implementationLanguages)) errors.push('response/response.json: the implementation tracks must cover exactly the declared implementation languages');
+    // The image stage is a decision, and a stage that is off produces nothing at all.
+    if (!imageOn && (imageFiles.length || promptFiles.length)) errors.push('response/response.json: stageModes turns the image off, so no image and no prompt may be produced');
+    if (imageOn && response.status === 'done' && (imageFiles.length === 0 || promptFiles.length === 0)) errors.push('response/response.json: stageModes turns the image on, so the unit carries an image and the prompt that states its intent');
+  }
+
+  let publishedOutcomes = [];
+  let publishedClaims = [];
+  let briefFingerprint = null;
+  if (present.has('content-brief') && has('response/brief.md')) {
+    const text = await read('response/brief.md');
+    const binding = fields(tableUnder(text, '## Binding'));
+    briefFingerprint = binding.Fingerprint;
+    if (!empty(requirements.unit) && binding.Unit !== requirements.unit) errors.push('response/brief.md: Unit differs from the request');
+    publishedOutcomes = (tableUnder(text, '## Outcomes') ?? []).map(([id]) => id);
+    publishedClaims = (tableUnder(text, '## Claims') ?? []).map(([id]) => id);
+    if (new Set(publishedOutcomes).size !== publishedOutcomes.length) errors.push('response/brief.md: an outcome is published twice');
+    if (new Set(publishedClaims).size !== publishedClaims.length) errors.push('response/brief.md: a claim is published twice');
+    for (const [kind, target] of tableUnder(text, '## Dispositions') ?? []) if (kind !== 'add' && empty(target)) errors.push(`response/brief.md: a ${kind} disposition must name what it acts on`);
+  }
+
+  let e2e = null;
+  if (present.has('e2e') && has('response/data/e2e.json')) { try { e2e = JSON.parse(await read('response/data/e2e.json')); } catch { e2e = null; } }
+  if (implementationLanguages.length === 0 && e2e !== null) errors.push('response/data/e2e.json: no implementation language is declared, so nothing was built and nothing ran');
+  if (implementationLanguages.length > 0 && e2e === null && response.status === 'done') errors.push('response/data/e2e.json: a unit that ships code ships the record of building and running it');
+  if (e2e) {
+    if (!empty(requirements.unit) && e2e.unitId !== requirements.unit) errors.push(`response/data/e2e.json: unitId ${e2e.unitId} differs from the request's ${requirements.unit}`);
+    if (e2e.maxIterations !== maxE2eIterations) errors.push(`response/data/e2e.json: maxIterations ${e2e.maxIterations} differs from the request's ${maxE2eIterations}`);
+    if (e2e.iterations > maxE2eIterations) errors.push(`response/data/e2e.json: the executable check spent ${e2e.iterations} iterations, past the bound of ${maxE2eIterations}`);
+    // The repair loop may fix the implementation. It may never move the contract it is measured by.
+    if (e2e.contractFingerprintBefore !== e2e.contractFingerprintAfter) errors.push('response/data/e2e.json: the executable contract changed during the repair loop, so the proof measures nothing');
+    const builtLanguages = e2e.tracks.map((t) => t.language);
+    if (new Set(builtLanguages).size !== builtLanguages.length) errors.push('response/data/e2e.json: a language cannot have two implementation tracks');
+    if (!sameSet(builtLanguages, implementationLanguages)) errors.push('response/data/e2e.json: the build records must cover exactly the declared implementation languages');
+    const runLanguages = e2e.runs.map((r) => r.language);
+    if (new Set(runLanguages).size !== runLanguages.length) errors.push('response/data/e2e.json: a language cannot have two executable-check runs');
+    if (!sameSet(runLanguages, builtLanguages)) errors.push('response/data/e2e.json: every implementation track must be exercised by the executable check');
+    const declaredCommands = new Map((Array.isArray(requirements.commands) ? requirements.commands : []).map((c) => [c.language, c]));
+    for (const track of e2e.tracks) {
+      const command = declaredCommands.get(track.language);
+      if (command && track.buildCommand !== command.buildCommand) errors.push(`response/data/e2e.json: the ${track.language} track was built with ${track.buildCommand}, the request declared ${command.buildCommand}`);
+      if (response.status === 'done' && track.exitCode !== 0) errors.push(`response/data/e2e.json: the ${track.language} track exits ${track.exitCode} and cannot be shipped as working code`);
+    }
+    for (const run of e2e.runs) {
+      const command = declaredCommands.get(run.language);
+      if (command && run.command !== command.checkCommand) errors.push(`response/data/e2e.json: the ${run.language} check ran ${run.command}, the request declared ${command.checkCommand}`);
+      if (response.status === 'done' && run.exitCode !== 0) errors.push(`response/data/e2e.json: the ${run.language} executable check exits ${run.exitCode} and proves nothing`);
+      if (response.status === 'done') for (const assertion of run.assertions) if (!assertion.held) errors.push(`response/data/e2e.json: the ${run.language} assertion ${assertion.name} did not hold, so the check proves nothing`);
+    }
+  }
+
+  const produced = [...articleFiles, ...trackFiles, ...imageFiles, ...promptFiles];
+  let verdict = null;
+  let round = null;
+  if (present.has('content-review') && has('review/response/review.md')) {
+    const text = await read('review/response/review.md');
+    const execution = fields(tableUnder(text, '## Execution'));
+    verdict = fields(tableUnder(text, '## Verdict')).Verdict;
+    round = Number(execution.Round);
+    // A unit that passes its own author's review has not been reviewed.
+    if (execution['Inherited turns'] !== 'none') errors.push('review/response/review.md: the review must be a fresh execution with no inherited turns');
+    if (execution['Producer rationale'] !== 'withheld') errors.push("review/response/review.md: the review may not receive the producer's rationale");
+    if (!Number.isInteger(round) || round < 1) errors.push('review/response/review.md: Round must be the number of this review round');
+    else if (round > maxReviewRounds) errors.push(`review/response/review.md: this is review round ${round}, past the approved maxReviewRounds of ${maxReviewRounds}`);
+
+    const received = (tableUnder(text, '## Received') ?? []).map(([artifact]) => artifact);
+    for (const ref of produced) if (!received.includes(ref)) errors.push(`review/response/review.md: the review never received ${ref}, so nothing reviewed it`);
+
+    const scores = (tableUnder(text, '## Scores') ?? []).filter(([, score]) => !empty(score)).map(([, score]) => Number(score));
+    const findings = tableUnder(text, '## Findings') ?? [];
+    const errorFindings = findings.filter(([, severity]) => severity === 'error');
+    if (verdict === 'approved') {
+      const lowest = scores.length ? Math.min(...scores) : 0;
+      if (lowest < MINIMUM_SCORE) errors.push(`review/response/review.md: the review approved the unit while a score sits at ${lowest}, below ${MINIMUM_SCORE}`);
+      if (errorFindings.length > 0) errors.push('review/response/review.md: the review approved the unit while an error finding remains open');
+    } else if (errorFindings.length === 0) errors.push('review/response/review.md: a revision verdict must name at least one error finding and its owning stage');
+    for (const [stage] of findings) {
+      if (stage === 'image' && !imageOn) errors.push('review/response/review.md: a finding cannot be assigned to the image stage, which stageModes turned off');
+      if ((stage === 'code' || stage === 'e2e') && implementationLanguages.length === 0) errors.push(`review/response/review.md: a finding cannot be assigned to the ${stage} stage, which never ran`);
+    }
+    if (response.status === 'done' && verdict !== 'approved') errors.push('review/response/review.md: a unit cannot be generated while the independent review demands a revision');
+  } else if (response.status === 'done') errors.push('review/response/review.md: a generated unit needs the review exchange');
+
+  // The revision fallback is bounded: every round past the first is one taken fallback, and the round
+  // after the last approved one is REVIEW_ROUNDS_EXHAUSTED rather than another quiet rewrite.
+  const revised = (response.fallbacks ?? []).includes('REVIEW_REVISION_REQUIRED');
+  if (revised && round !== null && round < 2) errors.push('response/response.json: REVIEW_REVISION_REQUIRED was taken, so the review that answered it is at least the second round');
+  if (!revised && round !== null && round > 1) errors.push(`response/response.json: this is review round ${round}, so the REVIEW_REVISION_REQUIRED fallback that reopened the exchange must be recorded`);
+  if (response.status === 'blocked' && response.stop === 'REVIEW_ROUNDS_EXHAUSTED' && round !== null && round !== maxReviewRounds) {
+    errors.push(`response/response.json: the rounds are exhausted only at round ${maxReviewRounds}, and the review is at round ${round}`);
+  }
+
+  if (present.has('content-generation-receipt') && has('response/response.md')) {
+    const text = await read('response/response.md');
+    const binding = fields(tableUnder(text, '## Binding'));
+    if (!empty(requirements.unit) && binding.Unit !== requirements.unit) errors.push('response/response.md: Unit differs from the request');
+    if (briefFingerprint !== null && binding['Brief fingerprint'] !== briefFingerprint) errors.push('response/response.md: Brief fingerprint differs from the frozen brief');
+    if (verdict !== null && binding.Verdict !== verdict) errors.push(`response/response.md: Verdict ${binding.Verdict} differs from the review's ${verdict}`);
+    if (round !== null && Number(binding.Round) !== round) errors.push(`response/response.md: Round ${binding.Round} differs from the review's ${round}`);
+
+    const editions = tableUnder(text, '## Editions') ?? [];
+    if (!sameSet(editions.map(([language]) => language), articleLanguages.filter(Boolean))) errors.push('response/response.md: the editions differ from the article files the response registers');
+    for (const [language, article, covered] of editions) {
+      const expected = `response/artifacts/article.${language}.md`;
+      if (article !== expected) errors.push(`response/response.md: the ${language} edition names ${article}, and an edition of ${language} is filed as ${expected}`);
+      const claimed = list(covered);
+      for (const ref of claimed) if (publishedOutcomes.length && !publishedOutcomes.includes(ref)) errors.push(`response/response.md: the ${language} edition claims outcome ${ref}, which the brief never published`);
+      if (response.status === 'done') for (const ref of publishedOutcomes) if (!claimed.includes(ref)) errors.push(`response/response.md: the ${language} edition leaves published outcome ${ref} uncovered`);
+    }
+
+    const approved = (tableUnder(text, '## Approved artifacts') ?? []).map(([artifact]) => artifact);
+    if (response.status === 'done') {
+      if (approved.length === 0) errors.push('response/response.md: a generated unit must name the artifacts the review approved');
+      for (const ref of approved) if (produced.length && !produced.includes(ref)) errors.push(`response/response.md: approved artifact ${ref} was never produced by this unit`);
+    }
+    // A stage that stayed off is a decision, and a decision that leaves no record reads later as an omission.
+    const recorded = new Set((tableUnder(text, '## Findings') ?? []).filter(([code]) => code === 'STAGE_DISABLED').map(([, stage]) => stage));
+    if (!imageOn && !recorded.has('image')) errors.push('response/response.md: the image stage stayed off and must be recorded as a STAGE_DISABLED finding');
+    if (implementationLanguages.length === 0) {
+      for (const stage of ['code', 'e2e']) if (!recorded.has(stage)) errors.push(`response/response.md: the ${stage} stage never ran and must be recorded as a STAGE_DISABLED finding`);
+    }
+  }
+  return { errors };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const target = process.argv[2];
+  if (!target) { process.stderr.write('usage: node validate.mjs <session>/step-N/parallel-M\n'); process.exit(2); }
+  const { errors } = await validateContentStep(path.resolve(target));
+  if (errors.length) { process.stderr.write(`${errors.join('\n')}\n`); process.exitCode = 1; } else process.stdout.write('valid content.generate branch\n');
+}

package/operators/errors.json

@@ -0,0 +1,178 @@
+{
+  "schemaVersion": 9,
+  "note": "Stop codes shared by more than one operator. `scope` is the list of operator ids that may emit the code, or [\"*\"] for every operator. A code only one operator emits lives in that operator's own operators/<id>/errors.json with the same entry shape and no scope; scripts/errors-registry.mjs merges both into one registry and refuses a code defined twice. A code has exactly one disposition: `terminate` ends the step with response.json status blocked and stop = code; `fallback` performs the named action, records it under `## Fallbacks taken` in response.md, and continues. `unless` is the only way a disposition changes: it names one Requirements param and the value that flips the code to `then`. `domain` is the routing.json domain the code hands to; `self` means the emitting operator's own domain (a resume). A runtime that meets a code the merged registry does not list terminates with UNKNOWN_STOP.",
+  "codes": {
+    "INVALID_INPUT": {
+      "scope": [
+        "*"
+      ],
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "request.json fails the gate or the operator's Requirements.",
+        "vi": "request.json không qua gate hoặc bảng Yêu cầu của operator."
+      },
+      "resume": {
+        "en": "Correct request.json.",
+        "vi": "Sửa request.json."
+      }
+    },
+    "SOURCE_DRIFT": {
+      "scope": [
+        "*"
+      ],
+      "domain": "workspace",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The observed checkout head differs from the head request.json froze.",
+        "vi": "Head quan sát được của checkout khác head mà request.json đã đóng băng."
+      },
+      "resume": {
+        "en": "The orchestrator freezes the head again.",
+        "vi": "Orchestrator đóng băng head lại."
+      }
+    },
+    "NO_PROGRESS": {
+      "scope": [
+        "*"
+      ],
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A resume adds no evidence, constraint, inventory, or approval delta.",
+        "vi": "Lần chạy lại không thêm bằng chứng, ràng buộc, inventory hay phê duyệt nào."
+      },
+      "resume": {
+        "en": "Bring a real delta.",
+        "vi": "Mang một delta thật."
+      }
+    },
+    "EVIDENCE_MISSING": {
+      "scope": [
+        "*"
+      ],
+      "domain": "self",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A claim about the system has no file, line, or head behind it.",
+        "vi": "Một khẳng định về hệ thống không có file, dòng hay head nào đứng sau."
+      },
+      "resume": {
+        "en": "Add the evidence.",
+        "vi": "Bổ sung bằng chứng."
+      }
+    },
+    "UNKNOWN_STOP": {
+      "scope": [
+        "*"
+      ],
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The runtime met a code the merged registry does not list.",
+        "vi": "Runtime gặp một mã mà sổ gộp không có."
+      },
+      "resume": {
+        "en": "Register the code or fix the operator.",
+        "vi": "Đăng ký mã hoặc sửa operator."
+      }
+    },
+    "OWNER_CONFLICT": {
+      "scope": [
+        "backend.source.apply",
+        "frontend.presentation.resolve",
+        "frontend.source.apply"
+      ],
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A node that must be mutated lies outside the mutable owner ceiling, or the owner sets overlap.",
+        "vi": "Một node cần sửa nằm ngoài trần owner được sửa, hoặc hai tập owner chồng nhau."
+      },
+      "resume": {
+        "en": "Correct the owner authority.",
+        "vi": "Sửa thẩm quyền owner."
+      }
+    },
+    "ROUTE_UNVERIFIED": {
+      "scope": [
+        "frontend.direction.decide",
+        "git.publish"
+      ],
+      "domain": "workspace",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The project or the routed frontend checkout identity is not verified.",
+        "vi": "Danh tính project hoặc checkout frontend được route chưa được xác minh."
+      },
+      "resume": {
+        "en": "Bind the route again.",
+        "vi": "Bind lại route."
+      }
+    },
+    "UNKNOWN_RULE": {
+      "scope": [
+        "frontend.presentation.resolve",
+        "frontend.surface.audit"
+      ],
+      "domain": "self",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "An identifier outside the bound rule inventory was reached for.",
+        "vi": "Một identifier ngoài kho luật đã bind bị với tới."
+      },
+      "resume": {
+        "en": "Bind the topic that publishes it, or correct the identifier.",
+        "vi": "Bind topic publish nó, hoặc sửa lại identifier."
+      }
+    },
+    "RUNTIME_UNAVAILABLE": {
+      "scope": [
+        "frontend.surface.audit",
+        "uat.verify"
+      ],
+      "domain": "platform",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The endpoint does not serve the bound route, or the surface never reaches readiness.",
+        "vi": "Endpoint không phục vụ route đã bind, hoặc bề mặt không bao giờ sẵn sàng."
+      },
+      "resume": {
+        "en": "Whoever runs the service serves the bound route; this operator never starts one.",
+        "vi": "Người vận hành dịch vụ cho route đã bind chạy; operator này không bao giờ tự khởi động."
+      }
+    },
+    "APPROVAL_REQUIRED": {
+      "scope": [
+        "business.decide",
+        "release.deploy"
+      ],
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The transition or the release needs an approval that no request bound.",
+        "vi": "Chuyển trạng thái hoặc release cần một phê duyệt mà request chưa ràng."
+      },
+      "resume": {
+        "en": "A person supplies the approval.",
+        "vi": "Người cấp phê duyệt."
+      }
+    },
+    "BRANCH_POLICY_VIOLATION": {
+      "scope": [
+        "git.publish",
+        "workspace.bind"
+      ],
+      "domain": "workspace",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The checkout is on a branch the routed Git policy forbids for this operation.",
+        "vi": "Checkout đang ở nhánh mà chính sách Git của route cấm với thao tác này."
+      },
+      "resume": {
+        "en": "Move to a permitted branch or change the routed policy.",
+        "vi": "Chuyển sang nhánh được phép hoặc đổi chính sách của route."
+      }
+    }
+  }
+}

package/operators/frontend-direction-decide/errors.json

@@ -0,0 +1,135 @@
+{
+  "schemaVersion": 9,
+  "note": "Stop codes frontend.direction.decide emits. Same entry shape as operators/errors.json, scope implicit. Shared codes (INVALID_INPUT, SOURCE_DRIFT, NO_PROGRESS, EVIDENCE_MISSING) come from operators/errors.json.",
+  "codes": {
+    "SCOPE_UNFROZEN": {
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The target or the boundary of the surface is incomplete, so the UI contract cannot be closed.",
+        "vi": "Target hay ranh giới của bề mặt còn thiếu, nên không đóng được UI contract."
+      },
+      "resume": {
+        "en": "Freeze the scope.",
+        "vi": "Đóng băng scope."
+      }
+    },
+    "CHANGE_LEVEL_AMBIGUOUS": {
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The authority for new, reconstruct or refine is unresolved or contradicts the intent.",
+        "vi": "Thẩm quyền cho new, reconstruct hay refine chưa rõ hoặc chỏi với intent."
+      },
+      "resume": {
+        "en": "State the exact change level.",
+        "vi": "Nêu đúng change level."
+      }
+    },
+    "OWNER_CEILING_INVALID": {
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The direction needs an owner the declared ceiling does not authorize.",
+        "vi": "Hướng cần một owner mà trần đã khai không uỷ quyền."
+      },
+      "resume": {
+        "en": "Correct the owner ceiling.",
+        "vi": "Sửa trần owner."
+      }
+    },
+    "BUSINESS_REQUIRED": {
+      "domain": "business",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "An actor, promise, permission, adverse outcome or recovery truth the change level requires is unresolved.",
+        "vi": "Một actor, lời hứa, quyền, kết cục bất lợi hay đường phục hồi mà change level đòi vẫn chưa được giải quyết."
+      },
+      "resume": {
+        "en": "Run business.decide first.",
+        "vi": "Chạy business.decide trước."
+      }
+    },
+    "BACKEND_REQUIRED": {
+      "domain": "backend",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The direction changes a data contract nobody delivered.",
+        "vi": "Hướng làm đổi một contract dữ liệu chưa ai giao."
+      },
+      "resume": {
+        "en": "Run backend.source.apply first.",
+        "vi": "Chạy backend.source.apply trước."
+      }
+    },
+    "ARCHITECTURE_REQUIRED": {
+      "domain": "architecture",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The direction changes a system or data boundary nobody decided.",
+        "vi": "Hướng làm đổi một ranh giới hệ thống hay dữ liệu chưa ai quyết."
+      },
+      "resume": {
+        "en": "Run architecture.decide first.",
+        "vi": "Chạy architecture.decide trước."
+      }
+    },
+    "GRAMMAR_REQUIRED": {
+      "domain": "grammar",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A family component the direction needs is unpublished; a composite is never assembled in its place.",
+        "vi": "Một component của họ mà hướng cần chưa được publish; không bao giờ được ghép tạm một cái thay thế."
+      },
+      "resume": {
+        "en": "A person publishes the component, and the same direction runs again.",
+        "vi": "Người publish component đó, rồi chính hướng ấy chạy lại."
+      }
+    },
+    "REFERENCE_EVIDENCE_EXHAUSTED": {
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "Bounded research cannot close the business or interaction question the decision rests on.",
+        "vi": "Nghiên cứu có giới hạn không lấp được câu hỏi nghiệp vụ hay tương tác mà quyết định dựa vào."
+      },
+      "resume": {
+        "en": "Supply the owning authority or a materially new reference.",
+        "vi": "Cấp thẩm quyền có chủ hoặc một tham chiếu mới về bản chất."
+      }
+    },
+    "NO_VIABLE_DIRECTION": {
+      "domain": "caller",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "Every candidate contradicts authority or fails a mandatory attack.",
+        "vi": "Mọi phương án đều chỏi thẩm quyền hoặc chết dưới một đòn tấn công bắt buộc."
+      },
+      "resume": {
+        "en": "Change the authority or the constraints; cosmetic variants are not a delta.",
+        "vi": "Đổi thẩm quyền hoặc ràng buộc; biến thể bề ngoài không phải delta."
+      }
+    },
+    "DIRECTION_CHOICE_REQUIRED": {
+      "domain": "caller",
+      "disposition": "fallback",
+      "meaning": {
+        "en": "Several candidates survive falsification and none dominates.",
+        "vi": "Nhiều phương án cùng sống sót qua phản chứng và không cái nào trội."
+      },
+      "fallback": {
+        "en": "Select the candidate that survived the most falsification attacks; on a tie, the one that introduces the fewest new nodes; record the table under ## Decision.",
+        "vi": "Chọn phương án sống sót qua nhiều đòn phản chứng nhất; hòa thì chọn phương án thêm ít node mới nhất; ghi bảng vào mục ## Decision."
+      },
+      "unless": {
+        "param": "selectionPolicy",
+        "equals": "approval-required",
+        "then": "terminate"
+      },
+      "resume": {
+        "en": "The person supplies approval naming one candidate.",
+        "vi": "Người nhập approval gọi tên một phương án."
+      }
+    }
+  }
+}

package/operators/frontend-direction-decide/operator.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 9,
+  "id": "frontend.direction.decide",
+  "domain": "frontend",
+  "job": "Decide one evidence-backed, implementation-ready frontend direction for one authorized target, and prove it against the business promise, the published Grammar, the observed implementation and a falsification pass that no candidate survives by taste.",
+  "package": "operator.md",
+  "errors": "errors.json",
+  "validator": "validate.mjs",
+  "selfTest": "self-test.mjs",
+  "resources": {
+    "profile": "sol-fresh",
+    "grammarBound": true,
+    "tools": {
+      "@tools/fileread": "context-aliases",
+      "@tools/git": "read",
+      "@tools/websearch": "bounded",
+      "@tools/imagegen": "judged",
+      "@tools/visualize": "html"
+    }
+  }
+}