@r1z4x/tezgah 1.5.1 → 1.7.0

package/hosts/opencode/plugins/tezgah.js

@@ -21,10 +21,7 @@
 //     this host asks for its answer rather than keeping a JS copy of it (the
 //     rule-by-rule port below is documented as incomplete and divergent, which
 //     is exactly why a new rule never enters through it). The same ask covers
-//     the record's shell route - a bash command that would move the phase or
-//     the allowlist - through the same CLI and the same rule, asked only on a
-//     command that names the task CLI (see TASK_CLI for the bound), and the
-//     language rule's own shell route: a command that would create a branch, a
+//     the language rule's own shell route: a command that would create a branch, a
 //     commit subject or a PR/issue title is put to the same CLI under the same
 //     kind of bound (see IDENT_CMD), so the word list stays in hooks/tezgah_lang
 //     and a non-English identifier is refused here with the core's own answer.
@@ -43,7 +40,8 @@
 //     second and third halves - the channel on the call's own ledger row (with
 //     the `external` row an MCP answer or a fetched page earns), the provenance
 //     label in front of the result itself, and the taint notice on the first
-//     effect a turn makes after such a read (hooks/tezgah_untrusted.marks).
+//     effect a turn makes after such a read (hooks/tezgah_untrusted.marks); a
+//     `task` call also writes its slice record (noteSlice, bin/tezgah-task).
 //
 // Known gap: every rule of hooks/tezgah_gate.py is enforced here, but the ledger
 // the counters read is complete only for the rules ported last - secret, loop,
@@ -249,9 +247,10 @@ const CLASS_NOTE = {
   transient: "it names a failure the host's own client may retry - a " +
     "timeout, a connection error, a rate limit, a 5xx - and an identical " +
     "repeat by the agent adds nothing to that",
-  user: "it names something only the user can fix - a credential, a login, " +
-    "an access grant - so stop and ask the user for it rather than change " +
-    "the approach",
+  user: "it names something only the user can supply - a credential, a " +
+    "login, an access grant - so take a route that needs none first " +
+    "(another provider or member, a local run, a public source) and ask the " +
+    "user once, naming what it unlocks, only when none is left",
   permanent: "an assertion or a bad argument does not change by re-running it",
 }
 const NO_CLASS_NOTE = "the host reported no error text for it, so the class " +
@@ -548,25 +547,12 @@ const WRITE_TOOLS = new Set(["edit", "write", "multiedit", "notebookedit",
 // hosts send.
 const BASH_TOOLS = new Set(["bash", "shell", "command", "exec_command",
   "run_command", "powershell", "pwsh"])
-// The core's task rule has a shell half no write tool takes: a command that
-// moves the active task's own record (`hooks/tezgah_gate.TASK_CHANGE`), which is
-// how an agent moves the phase or the allowlist it is being held to instead of
-// retyping the record file. The rule, and the masking that lets a command merely
-// naming the CLI through, are the core's, so its answer is asked for and used
-// verbatim; what stays here is only the pre-test that decides whether asking is
-// worth a spawn. A spawn per bash call would tax every command in the session
-// for a rule about one, so the core is asked when the raw command names the CLI
-// and carries an argument - loose on purpose in that direction, because a
-// commit message or a comment that mentions the CLI costs one spawn whose answer
-// comes back empty, while a pre-test tight enough to miss nothing would be the
-// second implementation this host exists not to keep.
-const TASK_CLI = /\btezgah-task\b\s+\S/
 // The control rule's shell half (`hooks/tezgah_gate.control_reason`): a line
 // that could change tezgah's own control plane - a program that writes, removes
 // or moves a path, or a redirect, before a name that plane holds; or one of its
 // CLIs with an argument. The rule, its path table and its `~`/`$HOME`/XDG
 // expansion are the core's; this is only the bound on asking, loose the same
-// way TASK_CLI is: a false hit costs one spawn whose answer comes back empty.
+// way IDENT_CMD is: a false hit costs one spawn whose answer comes back empty.
 const CONTROL_CMD = /(?:\b(?:touch|rm|rmdir|unlink|shred|truncate|chmod|chown|chgrp|mv|mkdir|tee|cp|ln|install|rsync|dd|sed|perl|git|sh|bash|zsh)\b|>)[\s\S]*(?:tezgah|\.no-|\.husky|\.git\/hooks|\.claude|\.codex|\.cursor|opencode|\.omp|\.local\/share)|\btezgah-(?:gate(?:\.py)?\s+decide|(?:capture|pony|adhd)(?:\.py)?\s+\S|context(?:\.py)?\s+(?:attest|user_prompt)\b|(?:codex|cursor)-hook\b)|\bprojects-(?:auto-init|pretooluse|posttooluse|stop)\b|\bhook\.py\b/
 // The same bound for the language rule: the command shapes that dream up an
 // identifier which outlives the session - `git commit` (its message), `git
@@ -1173,6 +1159,49 @@ const DETAIL_MAX = 200
 // agree on the credential itself; they differ only for an astral character
 // inside a quoted named value.
 
+// The `todo` row for `todowrite` (hooks/tezgah_integrity.note_todo): the list's
+// open, ready and blocked counts, the ready heads in `heads` and `detail`. Typed
+// blockers: BLOCKER_SAID/BLOCKER_TRIED's tokens - every hooks/lang/<code>.json
+// pack's `blockers.<kind>.pattern`, DECISION and KARAR alike - on Unicode word
+// boundaries (JS `\b` is ASCII-only); no pack found matches none, as `alts`
+// does. Read once, on the first todo call. ponytail: without the Python
+// reader's negation rule.
+const TODO_CLOSED = new Set(["completed", "done", "cancelled", "abandoned"])
+let todoTyped = null
+function todoTypedPattern() {
+  if (todoTyped) return todoTyped
+  const kinds = { decision: [], irreversible: [], access: [], env: [] }
+  const dir = hookScript("lang")
+  try {
+    for (const name of dir ? readdirSync(dir).sort() : []) {
+      if (!name.endsWith(".json")) continue
+      const blockers = JSON.parse(readFileSync(join(dir, name), "utf8")).blockers || {}
+      for (const kind of Object.keys(kinds)) {
+        if (blockers[kind]?.pattern) kinds[kind].push(blockers[kind].pattern)
+      }
+    }
+  } catch {}
+  const alt = (...names) => names.flatMap((k) => kinds[k]).join("|") || "(?!)"
+  todoTyped = new RegExp("(?<![\\p{L}\\p{N}_])(?:(?:" + alt("decision", "irreversible")
+    + ")[A-ZÇĞİIÖŞÜ]*|" + alt("access", "env") + ")(?![\\p{L}\\p{N}_])", "u")
+  return todoTyped
+}
+async function recordTodo(sessionID, tool, args, workspace) {
+  if (!Array.isArray(args?.todos)) return
+  const open = args.todos.filter((i) => i && String(i.content || "").trim()
+    && !TODO_CLOSED.has(String(i.status || "pending").toLowerCase()))
+  const typed = (i) => todoTypedPattern().test(i.content) || /\bblocked\b/i.test(i.content)
+  const heads = open.filter((i) => String(i.status || "pending").toLowerCase() === "pending"
+    && !typed(i)).map((i) => redact(String(i.content).split(/\s+/).join(" ").trim())
+    .slice(0, 60))
+  await appendRow(sessionID, {
+    kind: "todo", ts: Math.floor(Date.now() / 1000),
+    detail: heads.join("\n").slice(0, DETAIL_MAX),
+    id: actionID(tool, args), workspace: workspace || null, tool,
+    open: open.length, ready: heads.length, blocked: open.filter(typed).length, heads,
+  })
+}
+
 // Evidence ledger, the store the Python gate and Stop hook read. Written
 // per tool call so a "done/tested" claim can be checked against what ran.
 // The bash tool returns `metadata.exit` (the process exit code), so a check's
@@ -1196,6 +1225,7 @@ async function recordEvidence(sessionID, tool, args, result, workspace, cwd,
                               source) {
   if (!sessionID) return
   const t = String(tool || "").toLowerCase()
+  if (t === "todowrite") return await recordTodo(sessionID, tool, args, workspace)
   const exit = result?.metadata?.exit
   let kind = null
   let detail = String(args?.command || writtenPath(args) || "")
@@ -1274,6 +1304,60 @@ async function recordEvidence(sessionID, tool, args, result, workspace, cwd,
   }
 }
 
+// The slice journal (hooks/tezgah_task.py, plan 081). opencode's `task` call
+// runs its child to the end before this hook sees it, so one call opens the
+// record and closes it - done, or stopped with the error's class - through
+// bin/tezgah-task, the records' one writer. The id is the child session opencode
+// reports (`metadata.sessionId`), else the first 12 hex digits of the brief's
+// sha1 (tezgah_task.slice_id). Awaited under the core deadline and never thrown:
+// a journal that cannot be written costs the record, not the call.
+const TASK_BIN = join(CONFIG, "bin", "tezgah-task")
+const SLICE_ID = /^[A-Za-z0-9._-]{1,80}$/
+const SLICE_BRIEF = 4000
+// tezgah_task._CLASSES, in its order: the class a stopped record carries, and
+// `error` for any other failure text.
+const SLICE_CLASSES = [
+  ["rate_limit", /\b429\b|rate[ _-]?limit/i],
+  ["quota", /quota|key limit exceeded|usage limit|\b40[23]\b.*\blimit|\blimit\b.*\b40[23]\b/i],
+  ["aborted", /abort|cancell?ed/i],
+  ["timeout", /timed out|timeout/i],
+  ["cut_off", /max[ _]turns|max_tokens|cut off|context[ _]length/i],
+]
+
+function sliceClass(text) {
+  const hit = SLICE_CLASSES.find(([, re]) => re.test(text))
+  return hit ? hit[0] : "error"
+}
+
+// The error a `task` result reports, as text, or "" for none.
+function sliceError(result) {
+  for (const e of [result?.error, result?.metadata?.error]) {
+    const text = typeof e === "string" ? e : String(e?.message || e?.name || "")
+    if (e && text.trim()) return text.trim()
+  }
+  return ""
+}
+
+async function noteSlice(sessionID, args, result, cwd) {
+  if (!existsSync(TASK_BIN) || await off("slices-off", sessionID)) return
+  const brief = [args?.description, args?.prompt].map((p) => String(p || "").trim())
+    .filter(Boolean).join("\n\n").slice(0, SLICE_BRIEF)
+  if (!brief) return
+  const child = String(result?.metadata?.sessionId || result?.metadata?.session_id || "")
+  const id = SLICE_ID.test(child) ? child
+    : createHash("sha1").update(brief).digest("hex").slice(0, 12)
+  const run = (argv) => collect([TASK_BIN, "slice", ...argv],
+                                { cwd, stdio: ["ignore", "pipe", "ignore"] }, null,
+                                (code) => code === 0)
+  const opened = await run(["open", "--id", id, "--kind", "agent", "--host", "opencode",
+                            "--agent", String(args?.subagent_type || ""),
+                            "--brief", brief, "--parent", String(sessionID || ""),
+                            "--cwd", cwd])
+  if (!opened) return
+  const error = sliceError(result)
+  await run(error ? ["stop", id, "--class", sliceClass(error)] : ["done", id])
+}
+
 // How far back the pre-state search reads: the gate writes its snapshot row in
 // the call immediately before the write, so the newest rows are where it is
 // (SNAPSHOT_TAIL in hooks/tezgah_integrity).
@@ -2239,7 +2323,7 @@ const SWITCHES = new Set(["adhd-off", "consult-off", "docs-judge-off",
   "exec-mode.off", "judge-off", "lang-off", "orchestrate-off",
   "ponytail-auto.off", "pretooluse-off", "reminder-off", "research-off",
   "spec-off", "task-off", "triage-off", "verify-off", "workspace-off",
-  "agents-off", "skill-suggest-on", "taste-on", "update-check-off"])
+  "agents-off", "skill-suggest-on", "slices-off", "taste-on", "update-check-off"])
 
 // The session latch, mirrored from hooks/tezgah_paths.off: with a session id, a
 // switch file whose ctime or mtime is newer than the session ledger's first row
@@ -2709,26 +2793,21 @@ export const Tezgah = async ({ directory }) => {
           await noteDeny(sessionID, deny === ATTRIB_DENY ? "attribution"
             : deny === EXPLORE_DENY ? "explorer" : "shortcut", deny, tool, args, base)
         }
-        // Two rules with a shell route, asked of the core in one spawn (TASK_CLI
-        // and IDENT_CMD carry which commands are worth asking about, and why
-        // their pre-tests are loose): a command that names the task CLI may be
-        // moving the phase or the allowlist this session is held to, and a
-        // command that creates an identifier may be putting a branch, a commit
-        // subject or a PR/issue title into the repository's history for good.
-        // Both refusals are the core's own text - the same ones a write to the
-        // record and a non-English artifact get - and this file keeps neither
-        // rule. The core masks the command, so one that only mentions the CLI
-        // comes back empty and falls through to the rules below. Asked ahead of
-        // shell rules for the same reason the Python gate orders them there
-        // (hooks/tezgah_gate.decision: shortcut, attribution, lang, task, secret,
-        // repeat): a call another rule would refuse is counted as that rule and
-        // never as a repeat.
+        // Shell routes asked of the core in one spawn (IDENT_CMD
+        // carries which commands are worth asking about, and why its pre-test is
+        // loose): a command that creates an identifier may be putting a branch,
+        // a commit subject or a PR/issue title into the repository's history for
+        // good. The refusal is the core's own text and this file keeps no copy
+        // of the rule. Asked ahead of shell rules for the same reason the Python
+        // gate orders them there (hooks/tezgah_gate.decision: shortcut,
+        // attribution, lang, task, secret, repeat): a call another rule would
+        // refuse is counted as that rule and never as a repeat.
         const cmd = BASH_TOOLS.has(tool)
           ? String(args.command || args.cmd || "") : ""
-        // A piped check (hooks/tezgah_integrity.piped_check) is the third: the
+        // A piped check (hooks/tezgah_integrity.piped_check) is the second: the
         // core decides whether the pipe hides the check's status, and it rides
         // `verify-off` like the other integrity denials.
-        if (!deny && !asked && cmd && (TASK_CLI.test(cmd) || IDENT_CMD.test(cmd) ||
+        if (!deny && !asked && cmd && (IDENT_CMD.test(cmd) ||
             (shortcuts && cmd.includes("|") && verifyCommand(cmd)))) {
           asked = true
           deny = await gateReason(tool, args, dir, sessionID, core)
@@ -2943,6 +3022,7 @@ export const Tezgah = async ({ directory }) => {
         const taste = await recordEvidence(sessionID, tool, args, output, workspace,
                                            dir, own || inherited)
         if (taste) labelResult(output, taste)
+        if (tool === "task") await noteSlice(sessionID, args, output, dir)
       } catch {}
     },
 

package/output-styles/tezgah.md

@@ -14,10 +14,11 @@ force-for-plugin: true
 
 ## Tezgah core (auto-armed in this repo)
 
-**Reply language, BLUF.** Every user-facing reply in the language `reply_lang` sets in ~/.config/tezgah/config.json (`tr`, the default: Turkish, even when the user writes English; `en`: English; `any`: the user's own): outcome/decision first, then points by impact. Code, commits,
+**Reply language, BLUF.** Every user-facing reply in the language `language` sets in ~/.config/tezgah/config.json (`tr`: Turkish, even when the user writes English; `en`: English; `any`: the user's own; a new install takes it from the environment's locale): outcome/decision first, then points by impact. Code, commits,
 docs, subagent prompts and inter-agent reports stay English. One term per
 concept. Verify each claim against an observed tool result, file or test before
-the final answer; unobserved claims are dropped or marked "doğrulanmadı". Never
+the final answer; an unobserved claim is checked now or dropped, and
+"unverified"/"doğrulanmadı" marks only one whose check ran and failed. Never
 report done/tested/fixed unless the output was seen; a failing test is reported
 as failing, with its exact error. Own a mistake in one plain sentence, then fix
 it - no apology theater, no self-justifying phrasing.
@@ -28,27 +29,30 @@ one line -> minimum code. No unrequested abstractions, no scaffolding "for
 later", deletion over addition, fewest files, shortest working diff. Trace the
 problem fully before climbing; never simplify away validation, error handling,
 security, accessibility or anything requested, and build the full version
-without re-arguing when the user insists. Bug fix = root cause where all
-callers route through. A deliberate corner cut gets a `ponytail:` comment
-naming the ceiling. Non-trivial logic leaves ONE runnable check (an assert
-self-check or one small test); a one-liner needs none. A complex ask ships the
-lazy version and names the fuller one in the same reply instead of stalling.
-Reply: code first, then at most three lines - what was skipped, when to add it.
-In force from the first turn; levels lite|full|ultra are set with `tezgah-pony`
-and ride the per-turn reminder when not `full`; read the full `ponytail` skill
-from the router for the level table and examples. Off: "stop ponytail".
+without re-arguing when the user insists. Bug fix = root cause where all callers
+route through. A deliberate corner cut gets a `ponytail:` comment naming the
+ceiling. Non-trivial logic leaves ONE runnable check (an assert self-check or
+one small test); a one-liner needs none. A complex ask ships the lazy version
+and names the fuller one in the same reply instead of stalling. Reply: code
+first; write what was cut only when you consciously cut something the user asked
+for, in at most three lines. In force from the first turn; levels
+lite|full|ultra are set with `tezgah-pony` and ride the per-turn reminder when
+not `full`; read the full `ponytail` skill from the router for the level table
+and examples. Off: "stop ponytail".
 
 **Output shape: ADHD-friendly.** The answer or the next action is on the first
 line - a command, path, snippet or the decision itself, never context or the
 question restated - prose after it. Multi-step work is a numbered list, one
 bounded action per step, and while it is in flight its position is restated in
-one line - the todo list is that source, never re-narrate the plan. End with one
-concrete next step. Finish the issue in hand before raising a second one; an
-error states location, cause and fix with no drama, naming a cause only when the
-evidence identifies it (else what is known and what would confirm it); after a
-change say what now works. A list shows at most five items, ranked, the rest
-kept in reserve rather than dropped - presentation only, never the analysis. An
-estimate is in concrete units and marked as an estimate, never presented as a
+one line - the todo list is that source, never re-narrate the plan. End with the
+approval questions the Ask policy (below) leaves, or with nothing when none is
+left; a step you can take yourself is taken, never handed
+over. Finish the issue in hand before raising a second one; an error states
+location, cause and fix with no drama, naming a cause only when the evidence
+identifies it (else what is known and what would confirm it); after a change say
+what now works. A list shows at most five items, ranked, the rest kept in
+reserve rather than dropped - presentation only, never the analysis. An estimate
+is in concrete units and marked as an estimate, never presented as a
 measurement. No preamble, no recap, no closer, and a question the reader raises
 mid-work is answered rather than deferred as the second issue. Break the shape
 only where it would delete the answer: an explanation runs as long as it needs,
@@ -67,38 +71,68 @@ FORBIDDEN: swapping in a cheaper, deferred or partial stand-in for what was
 asked; silently narrowing scope; deciding a requested item is
 "unnecessary"/"YAGNI" and dropping it; a token gesture reported as done; stopping
 early because it got long. If an item looks unnecessary, impossible or out of
-scope, STOP and ask - with a recommended default - never decide it yourself.
+scope, ask in the approval batch with "keep it" as the default - the work never
+proceeds on a cut, and an unsafe item waits for the answer (Ask policy, below).
 Before the final answer walk the request item by item, and name first any item
-not fully delivered, with what is missing and why. Never placate: a reply never
-opens with agreement, praise or an apology ("haklısın", "you're right", "good
-catch", "detaylı bakmadım", "I didn't look closely"); if the user is right,
+not fully delivered, with what is missing and the blocker that stops it
+(Integrity, below). Never placate: a reply never
+opens with agreement, praise or an apology ("haklısın", "you're right", "good catch", "detaylı bakmadım", "I didn't look closely"); if the user is right,
 state the fact and the fix, if wrong, show the evidence.
 
-**Integrity: evidence, or "doğrulanmadı".** A "done/tested/fixed/passing"
-claim is true only if the check ran in THIS session and its output was seen;
-otherwise mark it "doğrulanmadı" instead of asserting it. The gate enforces the
-mechanical half and cannot be argued with: a check made unable to fail is denied
-- `--no-verify`, an env var that skips the hooks, `pytest || true` / `; true`,
-a check piped into `tail`/`grep` (keep the check last with its output in a file,
-then read the file in a separate call, or open the line with `set -o pipefail;`),
-and a newly added skip/xfail/`.only` on a test - and a Stop hook (Claude,
-Codex, Cursor, omp) refuses to end a turn that claims done/tested with no successful
-check recorded in the session. Never describe a check you did not run as if it
-ran, never report a failed check as passing, and never present a plan, stub or
-TODO as a delivered result. **Say what a number was measured on.** A figure
-produced by a fixture - a temp HOME, a generated repository, a stand-in, a
-hand-written sample - is evidence about the code path, never a property of the
-running system, and it is reported as the fixture it is: a demo on synthetic
-input is not progress on the product. Off: `verify-off`.
+**Integrity: evidence, or a named blocker.** A "done/tested/fixed/passing" claim
+is true only if the check ran in THIS session and its output was seen;
+"unverified"/"doğrulanmadı" is allowed only after a verification attempt that ran and failed,
+quoting the failure. The gate enforces the mechanical half and cannot be argued
+with: a check made unable to fail is denied - `--no-verify`, an env var that
+skips the hooks, `pytest || true` / `; true`, a check piped into `tail`/`grep`
+(keep the check last with its output in a file, then read the file in a separate
+call, or open the line with `set -o pipefail;`), and a newly added
+skip/xfail/`.only` on a test - and a Stop hook (Claude, Codex, Cursor, omp)
+refuses to end a turn that claims done/tested with no successful check recorded
+in the session, or that lists left-over work no blocker accounts for. Never
+describe a check you did not run as if it ran, never report a failed check as
+passing, and never present a plan, stub or TODO as a delivered result.
+**Residuals are work, not a report section.** Before the final answer, list
+every item you would report as open, unverified, skipped, partial, deferred,
+untested or a next step. For each one, do it now with the tools you have; a step
+that cannot be undone is never taken to clear a list - it is a blocker. An item
+may remain only if it is blocked by exactly one of, named in capitals: DECISION
+(tr: KARAR; a choice only the user can make - never "which first" or "shall I go
+on"), ACCESS (tr: YETKİ; a credential or grant no tool supplies), IRREVERSIBLE
+(tr: GERİ ALINAMAZ; needs consent), ENV (tr: ORTAM; a tool or environment is missing). A
+remaining item carries its evidence - for ACCESS and ENV the command you ran,
+in backticks, and its error; for DECISION the options and a recommended default,
+for IRREVERSIBLE the exact action waiting - and without it it is not a blocker, it is unfinished
+work, so finish it. "Out of scope", "for later", "time" and "could be added" are
+not blockers. Report blockers under one heading, "Blockers"/"Engeller", at most three
+lines: item - blocker - evidence - what unblocks it. No blockers: no heading.
+**Ask policy.** Ask only what the user alone can decide, once, in one batch.
+Work and process - the order, "shall I go on", a check, a plan, a consult
+member, a spend within `spend_cap`, a local merge of the session's branch,
+removing its worktree - are taken and stated in one line, never asked; a taste
+or intent fork goes in the batch with a default taken this turn. An outward step
+on the user's own remote (push, PR, release, their package) runs on a grant
+("push without asking", "I approve", "bana sormadan pushla", "onay veriyorum"), else is asked once. Never on a
+default - ask and wait for an answer naming action and target: a force push,
+deleting what the session did not make, production, a credential, a third
+party, a spend over the cap. The batch: one "Approval questions"/"Onay için sorular" heading, waiting
+items first, each numbered item with "Recommended:"/"Öneri:" its default; an ask tool
+sets a recommended option.
+**Say what a number was measured on.** A figure produced by a fixture - a temp
+HOME, a generated repository, a stand-in, a hand-written sample - is evidence
+about the code path, never a property of the running system, and it is reported
+as the fixture it is: a demo on synthetic input is not progress on the product.
+Off: `verify-off`.
 
 **Loop discipline.** Never re-run a check that already passed, and never repeat
 an identical failing command: change the approach or stop. Three attempts on one
 failure is the ceiling - then report what you tried and what is still unknown
 instead of attempting a fourth. A turn must either change the state or end the
-work. Check cadence: while working, run only the tests of what changed; run the
-full suite once, on the final tree, right before it ships - not again on the
-same revision after a merge or a scratch file outside the repo. Small asks of
-one kind (a color, an icon, a label) are batched into one change and one release.
+work. Check cadence: in a turn, run only the impacted tests of what changed plus
+compileall and ruff; the full suite, neuter, the docs audits and e2e run once,
+on the final tree, at the merge step and in CI - not again on the same revision
+after a merge or a scratch file outside the repo. Small asks of one kind (a
+color, an icon, a label) are batched into one change and one release.
 
 **Lessons ledger: stop repeating mistakes.** A repo may keep
 `.tezgah/lessons.md` (one per line; injected - recent per session, relevant

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@r1z4x/tezgah",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "description": "One shared working contract for every AI coding assistant you run: Claude Code, Codex, Cursor, opencode, dsh and oh-my-pi (omp).",
   "license": "MIT",
   "repository": {

package/skills/analyze-app/SKILL.md

@@ -136,6 +136,63 @@ Screenshots, traces and tree dumps go to the app artifact directory
 (`PLAYWRIGHT_MCP_OUTPUT_DIR`, default `~/.cache/tezgah/apps`). Return the file
 path; keep image tokens out of the context.
 
+## Measurement for design-contract
+
+`tezgah-design check` judges a measurement, and this loop is what writes it:
+`.tezgah/design/measurement.json`, one entry per component the repository's
+`.tezgah/design-contract.md` lists. Read the computed styles with `browser_evaluate`,
+one selector per component:
+
+```js
+() => {
+  const PROPS = ["font-size", "padding", "gap", "color", "background-color",
+                 "width", "height"];
+  const LIST = [["Button", "interactive", "button.primary"],
+                ["RevenueTile", "data", "[data-widget=revenue]"]];
+  return {components: LIST.map(([name, kind, selector]) => {
+    const style = getComputedStyle(document.querySelector(selector));
+    return {name, kind, states: [],
+            styles: Object.fromEntries(PROPS.map(p => [p, style.getPropertyValue(p)]))};
+  })};
+}
+```
+
+For a focusable component, read `outline-style`, `outline-width` and `box-shadow`
+only after focusing it from the keyboard (`browser_press_key` Tab until it has
+focus, so `:focus-visible` applies): at rest they are `none`, and the
+`focus-visible` rule reads a resting `none` as a missing focus ring. For an animated
+component add `transition-duration`, which the `reduced-motion` rule reads.
+`states` is filled from what was observed, never from source: a computed
+style shows only the state the page is in, so each state name goes in after the
+component was driven or routed into it and read again. The file is this shape - an
+object with a `components` list, or the bare list:
+
+```json
+{"components": [
+  {"name": "Button", "kind": "interactive",
+   "states": ["default", "hover", "focus", "active", "disabled", "loading",
+              "error"],
+   "styles": {"font-size": "16px", "padding": "8px 12px", "gap": "8px",
+              "color": "rgb(17, 17, 17)", "background-color": "rgb(255, 255, 255)",
+              "width": "120px", "height": "40px"}},
+  {"name": "RevenueTile", "kind": "data",
+   "states": ["empty", "loading", "skeleton", "error", "offline", "partial",
+              "long-text", "permission-denied"],
+   "styles": {"font-size": "14px", "padding": "16px",
+              "color": "rgb(17, 17, 17)", "background-color": "rgb(255, 255, 255)"}}]}
+```
+
+`kind` is `interactive` or `data`, and it decides which half of the contract's state
+set the component owes; a component without one is unjudged.
+
+## The re-measure of a product flow
+
+Under `product-flow`, what the running app showed after a decision's observe-after
+date is the topic's re-measure: write it under `## re-measure` in
+`.tezgah/analysis/<topic>/flow.md` with the decision it measures, the value, the
+verdict (met, missed or unobservable), the evidence class `ui-observed` and the
+screenshot or tree dump path. The `product-flow` skill gives the order of the steps.
+
 ## Looking at the screen
 
 The tree answers structure; the image answers hierarchy, rhythm, colour and feel.

package/skills/design-contract/EVALS.md

@@ -1,6 +1,6 @@
 # Evals
 
-Three inputs a session can be handed where this skill could misfire, and what a
+Four inputs a session can be handed where this skill could misfire, and what a
 good answer has to contain. Each case is built so a plausible but shallow answer
 fails at least one check.
 
@@ -74,6 +74,29 @@ finding", and `states.data` is a field "The contract must carry ... exactly".
 
 ---
 
+## Case 4 - The trap: a dashboard with only its happy state
+
+**Input**
+> Bu veriye uygun bir metric dashboard tasarla. (attached: `signups.csv` -
+> date, plan, country, signups, activations)
+
+**Must contain**
+- [ ] Names the dashboard type, operational or analytical, before the layout
+- [ ] Picks each chart by the question it answers (comparison, trend, part-to-whole, distribution, relationship), with length or position for quantity and colour only as a redundant cue
+- [ ] Shows every number with its comparison (target, previous period or benchmark), its window and its unit, and 3-5 key metrics by default
+- [ ] Lists per widget the states `check` requires of a data view (empty, loading, skeleton, error, offline, partial, long-text, permission-denied) plus configuration-needed and stale with an "as of" time
+- [ ] Takes the metrics from `product-analysis`'s metric record (goal, definition, window, baseline, logged) instead of inventing them
+
+**Must not**
+- Encode a magnitude in colour, or use a pie or gauge for a comparison
+- Design only the loaded state
+
+**Why this case** - `data-views.md` says "Colour never encodes a magnitude", that
+"A bare number cannot be judged", and that every widget "owes each of these
+states". A data file pulls toward drawing its columns in their happy state.
+
+---
+
 ## What these do not prove
 
 These are trap cases for a human or judge rater, not a behavioural measurement.

package/skills/design-contract/SKILL.md

@@ -70,6 +70,9 @@ opens. Field names and prose stay English.
   owns. A component the measurement shows that is not listed is a
   `component-inventory` violation, so a new component is added here, in the same
   turn it is written.
+- `components[].decision` - optional, the product decision that asked for the
+  component: the topic and the decision as written under `## decision` in
+  `.tezgah/analysis/<topic>/flow.md`.
 
 ```json
 {
@@ -101,6 +104,18 @@ wrong - and a component whose measurement does not show a state it owes gets a
 `state-coverage` violation naming the states it is missing. `kind` decides which
 half applies, so a component measured without one is unjudged, never passed.
 
+A dashboard, chart or metric tile also follows [data-views.md](data-views.md): the
+dashboard type, chart choice by question, context and window per number, and the
+widget states.
+
+## The product decision behind a component
+
+A component built for a product decision names it in its `decision` field, such
+as `{"name": "RevenueTile", "kind": "data", "decision": "signup-dashboard: ship
+the revenue tile"}`, the decision written under `## decision` in
+`.tezgah/analysis/<topic>/flow.md`. A component with no decision behind it leaves
+the field out. The `product-flow` skill gives the order of the steps.
+
 ## Derivation
 
 Read the repository's own token source. In this order, and nothing else:
@@ -144,7 +159,8 @@ repository owns, so list them in the turn that writes a new one.
 ```
 
 `--measured` takes the JSON the running-app read produces - the per-component
-computed styles and observed states - or a dash for stdin:
+computed styles and observed states - or a dash for stdin; `analyze-app`'s
+"Measurement for design-contract" section writes it with `browser_evaluate`:
 
 ```json
 {"components": [