@techierathore/techieflow 1.1.0 → 1.2.0

package/.tfcore/utils/tf-verify-zoom.mjs

@@ -0,0 +1,193 @@
+// tf-verify-zoom.mjs — presses the OS zoom keys on a Blazor Hybrid head and measures what they did
+// (coding-standards-dotnet.md §9b; Lekhak, 2026-10-11). Called by tf-verify-zoom.sh; see there.
+//
+// Mac (--appium): mac2 presses Cmd+= / Cmd+- / Cmd+0 as real keys, so they go through the menu bar the
+// way a person's do; macOS takes the window alone after each. The accessibility tree does not follow a
+// WKWebView's page zoom (its text heights stayed 13 px at 130% on BlogAdmin), so the level is measured
+// from the pictures: the scale that best maps the actual-size picture onto the zoomed one, from the
+// first row where the two differ (the web view's top edge; the title bar above it does not zoom).
+// Windows and any Chromium web view (--cdp): Playwright presses Ctrl+= / Ctrl+- / Ctrl+0 in the page
+// and reads the zoom it paints at (CSS zoom on <html> times the device pixel ratio).
+
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { inflateSync } from 'node:zlib';
+import { join } from 'node:path';
+
+const args = process.argv.slice(2);
+const opt = (k, d = '') => { const i = args.indexOf(k); return i >= 0 && i + 1 < args.length ? args[i + 1] : d; };
+const flag = (k) => args.includes(k);
+const OUT = opt('--out', 'tests/.artifacts/verify/zoom');
+const LEAVE = parseInt(opt('--leave', '0'), 10) || 0;
+const STEPS = [
+  // what is pressed, how often, the level expected afterwards (1.0 = actual size)
+  { key: 'reset', n: 1, want: 1.0, say: 'actual size' },
+  { key: 'in', n: 3, want: 1.3, say: 'zoom in 3 times' },
+  { key: 'out', n: 1, want: 1.2, say: 'zoom out once' },
+  { key: 'reset', n: 1, want: 1.0, say: 'actual size again' },
+];
+const TOL = 0.05;
+
+// ---- PNG, 8-bit RGB or RGBA, not interlaced: what screencapture and sips write -------------------
+export function decodePng(buf) {
+  let p = 8, w = 0, h = 0, ct = 0; const idat = [];
+  while (p < buf.length) {
+    const len = buf.readUInt32BE(p); const type = buf.toString('latin1', p + 4, p + 8);
+    const data = buf.subarray(p + 8, p + 8 + len);
+    if (type === 'IHDR') { w = data.readUInt32BE(0); h = data.readUInt32BE(4); ct = data[9]; if (data[8] !== 8 || data[12]) throw new Error('only 8-bit, non-interlaced PNG'); }
+    if (type === 'IDAT') idat.push(data);
+    if (type === 'IEND') break;
+    p += 12 + len;
+  }
+  const bpp = ct === 6 ? 4 : ct === 2 ? 3 : ct === 0 ? 1 : ct === 4 ? 2 : 0;
+  if (!bpp) throw new Error(`PNG colour type ${ct} not read`);
+  const raw = inflateSync(Buffer.concat(idat)); const stride = w * bpp;
+  const px = Buffer.alloc(h * stride); const gray = new Float32Array(w * h);
+  for (let y = 0; y < h; y++) {
+    const f = raw[y * (stride + 1)]; const src = y * (stride + 1) + 1; const row = y * stride;
+    for (let x = 0; x < stride; x++) {
+      const a = x >= bpp ? px[row + x - bpp] : 0; const b = y ? px[row - stride + x] : 0; const c = x >= bpp && y ? px[row - stride + x - bpp] : 0;
+      let v = raw[src + x];
+      if (f === 1) v += a; else if (f === 2) v += b; else if (f === 3) v += (a + b) >> 1;
+      else if (f === 4) { const pp = a + b - c; const pa = Math.abs(pp - a), pb = Math.abs(pp - b), pc = Math.abs(pp - c); v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c; }
+      px[row + x] = v & 255;
+    }
+    for (let x = 0; x < w; x++) { const o = row + x * bpp; gray[y * w + x] = bpp >= 3 ? 0.299 * px[o] + 0.587 * px[o + 1] + 0.114 * px[o + 2] : px[o]; }
+  }
+  return { w, h, gray };
+}
+
+// a picture shrunk to 640 px wide by sips (macOS), so the search stays quick
+function load(file) {
+  const small = file.replace(/\.png$/, '.small.png');
+  try { execFileSync('sips', ['-Z', '1000', file, '--out', small], { stdio: 'ignore' }); } catch { /* not macOS: read it whole */ }
+  return decodePng(readFileSync(existsSync(small) ? small : file));
+}
+
+// The page zoom that turns picture `base` (actual size) into picture `zoomed`. Page zoom scales every
+// horizontal position from the web view's left edge, but not always vertical ones: a header or sidebar
+// sized to the window height keeps its height (BlogAdmin's did), so a 2-D match read 121% for 130%.
+// So the two pictures are compared across the window only: for each column, how much vertical edge
+// (a border, a box side, the strokes of text) it holds below the title bar, and the scale that best
+// lines the actual-size profile up with the zoomed one. The title bar is the rows the two share.
+export function scaleBetween(zoomed, base) {
+  const { w, h } = base; if (zoomed.w !== w || zoomed.h !== h) return { scale: 0, why: 'the two pictures differ in size' };
+  let top = 0;
+  for (; top < h; top++) { let d = 0; for (let x = 0; x < w; x++) d += Math.abs(zoomed.gray[top * w + x] - base.gray[top * w + x]); if (d / w > 2) break; }
+  if (top >= h - 10) return { scale: 1, top, why: 'the pictures are the same' };
+  const profile = (img) => {
+    const p = new Float64Array(w);
+    for (let y = top; y < h; y++) for (let x = 0; x + 1 < w; x++) p[x] += Math.abs(img.gray[y * w + x + 1] - img.gray[y * w + x]);
+    return p;
+  };
+  const pz = profile(zoomed), pb = profile(base);
+  let best = { scale: 0, r: -2 };
+  for (let s = 0.5; s <= 3.0001; s += 0.01) {
+    let n = 0, sa = 0, sb = 0, saa = 0, sbb = 0, sab = 0;
+    for (let x = 0; x < w; x++) {
+      const bx = x / s; const i = Math.floor(bx); if (i + 1 >= w) break;
+      const a = pz[x], b = pb[i] + (pb[i + 1] - pb[i]) * (bx - i);
+      n++; sa += a; sb += b; saa += a * a; sbb += b * b; sab += a * b;
+    }
+    if (n < w / 4) continue;
+    const r = (sab - (sa * sb) / n) / Math.sqrt(Math.max(1e-9, (saa - (sa * sa) / n) * (sbb - (sb * sb) / n)));
+    if (r > best.r) best = { scale: Math.round(s * 100) / 100, r };
+  }
+  return { scale: best.scale, top };
+}
+
+const RESULT = { checks: [], kept_checked: false, head: '', evidence: '' };
+const line = (ok, text) => { console.log(`${ok ? 'OK  ' : 'FAIL'} ${text}`); RESULT.checks.push({ ok, text }); return ok; };
+
+async function mac() {
+  const { openSession, parseSource, appPid, windowShot } = await import('./tf-appium.mjs');
+  let boot = {}; try { boot = JSON.parse(readFileSync('tests/.artifacts/verify/boot.json', 'utf8')); } catch { /* flags only */ }
+  const appPath = opt('--app', boot.app_path || ''); const bundleId = opt('--bundle', boot.bundle || '');
+  let s;
+  try { s = await openSession(opt('--appium'), { bundleId, appPath }); }
+  catch (e) { line(false, `no session on the app at ${opt('--appium')}: ${e.message} (boot it with bash .tfcore/utils/tf-verify-boot.sh start --head maccatalyst)`); return 2; }
+  const pid = appPid(appPath);
+  let ok = true; let k = 0;
+  const shot = (name, same = false) => { const f = join(OUT, `${String(same ? k : k++).padStart(2, '0')}-${name}-mac.png`); return windowShot(pid, f) ? f : ''; };
+  const press = async (key) => {
+    await s.call('POST', '/execute/sync', { script: 'macos: keys', args: [{ keys: [{ key: { in: '=', out: '-', reset: '0' }[key], modifierFlags: 1 << 4 }] }] });
+    await new Promise((r) => setTimeout(r, 700));
+  };
+  // the View menu names the three commands
+  const nodes = parseSource(await s.source());
+  const view = nodes.find((n) => n.type === 'MenuBarItem' && /^view$/i.test(n.title || n.label));
+  const items = []; if (view) { const todo = [...view.kids]; while (todo.length) { const n = nodes[todo.shift()]; if (n.type === 'MenuItem') items.push(n.title || n.label); todo.push(...n.kids); } }
+  const missing = ['Zoom In', 'Zoom Out', 'Actual Size'].filter((t) => !items.includes(t));
+  ok = line(!missing.length, missing.length ? `the View menu has no ${missing.join(', ')} (it has: ${items.filter(Boolean).join(', ') || 'no View menu'})` : 'View › Zoom In, Zoom Out, Actual Size are in the menu bar') && ok;
+  // A mac2 session starts the app again: wait for a drawn page that holds still for two pictures
+  // (the first ones on BlogAdmin were the bare window while Blazor started)
+  const ink = (f) => { const g = load(f); let e = 0; for (let i = 1; i < g.gray.length; i++) e += Math.abs(g.gray[i] - g.gray[i - 1]); return e / g.gray.length; };
+  let opened = ''; let last = -1;
+  for (let t = Date.now(); Date.now() - t < 60000;) {
+    const f = shot('as-opened', true); const e = f ? ink(f) : 0;   // a bare window reads 0.04, a drawn page 0.96
+    if (e > 0.2 && last > 0 && Math.abs(e - last) / last < 0.02) { opened = f; break; }
+    last = e; await new Promise((r) => setTimeout(r, 1500));
+  }
+  k++;
+  if (!opened) { await s.close(); line(false, 'the app showed no drawn page within 60 s'); return 2; }
+  await press('reset'); const actual = shot('actual-size');
+  if (!opened || !actual) { await s.close(); return line(false, 'could not take the window (the terminal needs Screen Recording)') ? 0 : 5; }
+  RESULT.head = 'maccatalyst'; RESULT.evidence = actual;
+  const base = load(actual);
+  const restored = scaleBetween(load(opened), base).scale;
+  console.log(`INFO opened at ${Math.round(restored * 100)}% (the level the last run left; run again after a restart with --leave 3 before it to check the level is kept)`);
+  if (flag('--expect-restored')) RESULT.kept_checked = true;
+  if (flag('--expect-restored')) ok = line(Math.abs(restored - parseFloat(opt('--expect-restored'))) <= TOL, `opened at ${Math.round(restored * 100)}%, expected ${Math.round(parseFloat(opt('--expect-restored')) * 100)}% from the last run`) && ok;
+  for (const st of STEPS.slice(1)) {
+    for (let i = 0; i < st.n; i++) await press(st.key);
+    const f = shot(st.key); const got = f ? scaleBetween(load(f), base).scale : 0;
+    ok = line(Math.abs(got - st.want) <= TOL, `${st.say} (Cmd+${{ in: '=', out: '-', reset: '0' }[st.key]}): ${Math.round(got * 100)}%, expected ${Math.round(st.want * 100)}%`) && ok;
+  }
+  for (let i = 0; i < LEAVE; i++) await press('in');
+  if (LEAVE) console.log(`INFO left at ${100 + LEAVE * 10}% for the restart check`);
+  await s.close();
+  return ok ? 0 : 5;
+}
+
+async function cdp() {
+  const { chromium } = await import('playwright');
+  let browser;
+  try { browser = await chromium.connectOverCDP(opt('--cdp')); }
+  catch (e) { line(false, `nothing answers at ${opt('--cdp')}: ${e.message.split('\n')[0]}`); return 2; }
+  const page = browser.contexts().flatMap((c) => c.pages()).find((p) => !p.url().startsWith('devtools:')) || null;
+  if (!page) { line(false, 'no page to drive at ' + opt('--cdp')); return 2; }
+  const level = () => page.evaluate(() => (parseFloat(getComputedStyle(document.documentElement).zoom) || 1) * window.devicePixelRatio);
+  let ok = true; let k = 0;
+  const press = async (key) => { await page.keyboard.press({ in: 'Control+Equal', out: 'Control+Minus', reset: 'Control+Digit0' }[key]); await page.waitForTimeout(400); };
+  RESULT.head = 'cdp';
+  const opened = await level(); await press('reset'); const base = await level();
+  console.log(`INFO opened at ${Math.round((opened / base) * 100)}% (the level the last run left)`);
+  if (flag('--expect-restored')) RESULT.kept_checked = true;
+  if (flag('--expect-restored')) ok = line(Math.abs(opened / base - parseFloat(opt('--expect-restored'))) <= TOL, `opened at ${Math.round((opened / base) * 100)}%, expected ${Math.round(parseFloat(opt('--expect-restored')) * 100)}%`) && ok;
+  for (const st of STEPS.slice(1)) {
+    for (let i = 0; i < st.n; i++) await press(st.key);
+    await page.screenshot({ path: join(OUT, `${String(k++).padStart(2, '0')}-${st.key}-cdp.png`) }).catch(() => {});
+    const got = (await level()) / base;
+    ok = line(Math.abs(got - st.want) <= TOL, `${st.say} (Ctrl+${{ in: '=', out: '-', reset: '0' }[st.key]}): ${Math.round(got * 100)}%, expected ${Math.round(st.want * 100)}%`) && ok;
+  }
+  // Ctrl+wheel up is one step in
+  await page.mouse.move(200, 200); await page.keyboard.down('Control'); await page.mouse.wheel(0, -100); await page.keyboard.up('Control'); await page.waitForTimeout(400);
+  const wheel = (await level()) / base;
+  ok = line(Math.abs(wheel - 1.1) <= TOL, `Ctrl+wheel up: ${Math.round(wheel * 100)}%, expected 110%`) && ok;
+  await press('reset');
+  for (let i = 0; i < LEAVE; i++) await press('in');
+  if (LEAVE) console.log(`INFO left at ${100 + LEAVE * 10}% for the restart check`);
+  await browser.close().catch(() => {});
+  return ok ? 0 : 5;
+}
+
+if (process.argv[1] && process.argv[1].endsWith('tf-verify-zoom.mjs')) {
+  if (flag('--scale')) {           // tf-verify-zoom.mjs --scale <zoomed.png> <actual.png>: the measure alone
+    console.log(scaleBetween(load(args[args.indexOf('--scale') + 1]), load(args[args.indexOf('--scale') + 2])).scale);
+    process.exit(0);
+  }
+  mkdirSync(OUT, { recursive: true });
+  const rc = flag('--appium') ? await mac() : flag('--cdp') ? await cdp() : (console.error('tf-verify-zoom: --appium <url> or --cdp <url>'), 3);
+  if (opt('--json-out')) writeFileSync(opt('--json-out'), JSON.stringify({ ...RESULT, verdict: rc === 0 ? 'PASS' : 'FAIL' }, null, 1));
+  process.exit(rc);
+}

package/.tfcore/utils/tf-verify-zoom.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# tf-verify-zoom.sh — presses the OS zoom keys on a booted Blazor Hybrid head and says what they did
+# (coding-standards-dotnet.md §9b; Lekhak, 2026-10-11).
+#
+#   bash .tfcore/utils/tf-verify-zoom.sh --appium http://localhost:4723 [--leave 3] [--expect-restored 1.3]
+#        a Mac Catalyst head booted by tf-verify-boot.sh (its .app and bundle come from boot.json)
+#   bash .tfcore/utils/tf-verify-zoom.sh --cdp <the boot url> [--leave 3] [--expect-restored 1.3]
+#        a Windows (WebView2) head, or any Chromium web view, over its debugging address
+#
+# Checks, in order: (Mac) View › Zoom In, Zoom Out and Actual Size are in the menu bar; the level the
+# app opened at is printed, then Cmd/Ctrl+0 is actual size; zoom in 3 times reads 130%, zoom out once
+# 120%, actual size 100%; (Windows) Ctrl+wheel up reads 110%. The kept level across a restart is two
+# runs: the first with --leave 3 (it ends at 130%), then stop and start the head, then the second with
+# --expect-restored 1.3. Pictures go to tests/.artifacts/verify/zoom/. The Mac level is measured from
+# the window's pictures, because a WKWebView's accessibility tree does not follow its page zoom.
+# Exit 0 every check passed · 5 one failed · 2 nothing to drive · 3 usage · 4 Playwright missing (--cdp).
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+case "${1:-}" in
+  -h|--help) sed -n '2,19p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  "")        sed -n '2,19p' "$0" | sed 's/^# \{0,1\}//'; exit 3 ;;
+esac
+command -v node >/dev/null 2>&1 || { echo "tf-verify-zoom: node is required (bash .tfcore/utils/tf-verify-env.sh)" >&2; exit 4; }
+case " $* " in *" --cdp "*)
+  node -e "import('playwright').then(()=>process.exit(0)).catch(()=>process.exit(1))" 2>/dev/null || {
+    echo "tf-verify-zoom: the 'playwright' package is not resolvable from this folder; run bash .tfcore/utils/tf-verify-env.sh" >&2; exit 4; } ;;
+esac
+source "$HERE/tf-lock.sh"; tf_take_lock verify-screens   # one check drives the app at a time
+node "$HERE/tf-verify-zoom.mjs" "$@"

package/.tfcore/utils/tf-yolo-alias.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# tf-yolo-alias.sh — put the `tfyolo` command in this machine's shell profile, once (owner, 2026-10-14).
+#
+#   bash .tfcore/utils/tf-yolo-alias.sh install    add it to ~/.bashrc and/or ~/.zshrc (idempotent)
+#   bash .tfcore/utils/tf-yolo-alias.sh remove     take it out again
+#   bash .tfcore/utils/tf-yolo-alias.sh status     say where it is
+#
+# `tfyolo` is a small shell function, the same text in bash and zsh. Typed anywhere inside a
+# TechieFlow project, it finds the project's .tfcore/utils/tf-yolo-start.sh above the current folder
+# and runs it: YOLO on, Claude Code started in bypass mode in this terminal, YOLO off when the session
+# ends. `tfyolo -c` continues the last conversation. It never opens or closes a window: exit the
+# session you are in (/exit), then type it in the same terminal, or type it in another tab.
+# The function lives between two marker lines and is replaced whole on a second install, so an update
+# to it reaches the profile by running install again. Profiles: ~/.zshrc when the login shell is zsh
+# or the file exists (macOS), ~/.bashrc when the login shell is bash or the file exists (WSL, Linux).
+# A new terminal picks it up; an open one needs `source ~/.bashrc` (or ~/.zshrc). Exit 0; 2 bad use.
+
+set -u
+BEGIN="# >>> TechieFlow tfyolo >>>"
+END="# <<< TechieFlow tfyolo <<<"
+HOME_DIR="${TF_HOME:-$HOME}"
+
+block() {
+  cat <<'FN'
+# >>> TechieFlow tfyolo >>>
+# Start Claude Code in bypass mode with TechieFlow YOLO on, in the project around this folder.
+# `tfyolo -c` continues the last conversation. Added by .tfcore/utils/tf-yolo-alias.sh; remove with
+# `bash .tfcore/utils/tf-yolo-alias.sh remove`.
+tfyolo() {
+  _tf_d="$PWD"
+  while [ "$_tf_d" != "/" ] && [ ! -f "$_tf_d/.tfcore/utils/tf-yolo-start.sh" ]; do _tf_d="$(dirname "$_tf_d")"; done
+  if [ ! -f "$_tf_d/.tfcore/utils/tf-yolo-start.sh" ]; then
+    echo "tfyolo: no TechieFlow project around $PWD (no .tfcore/utils/tf-yolo-start.sh above it)" >&2
+    unset _tf_d; return 2
+  fi
+  bash "$_tf_d/.tfcore/utils/tf-yolo-start.sh" "$@"
+  _tf_rc=$?; unset _tf_d; return $_tf_rc
+}
+# <<< TechieFlow tfyolo <<<
+FN
+}
+
+profiles() {
+  local sh; sh="$(basename "${SHELL:-}")"
+  [[ "$sh" == zsh || -f "$HOME_DIR/.zshrc" ]] && echo "$HOME_DIR/.zshrc"
+  [[ "$sh" == bash || -f "$HOME_DIR/.bashrc" ]] && echo "$HOME_DIR/.bashrc"
+  [[ "$sh" != zsh && "$sh" != bash && ! -f "$HOME_DIR/.zshrc" && ! -f "$HOME_DIR/.bashrc" ]] && echo "$HOME_DIR/.bashrc"
+  return 0
+}
+
+strip() {  # the file without our block
+  awk -v b="$BEGIN" -v e="$END" '$0==b{skip=1;next} $0==e{skip=0;next} !skip' "$1"
+}
+
+case "${1:-status}" in
+  install)
+    while IFS= read -r p; do
+      [[ -n "$p" ]] || continue
+      tmp="$p.tftmp.$$"
+      if [[ -f "$p" ]]; then strip "$p" > "$tmp"; else : > "$tmp"; fi
+      # one blank line before the block, never a growing run of them
+      [[ -s "$tmp" && -n "$(tail -c 1 "$tmp")" ]] && echo "" >> "$tmp"
+      block >> "$tmp"
+      cat "$tmp" > "$p"; rm -f "$tmp"
+      echo "tfyolo: installed in $p (open a new terminal, or: source $p)"
+    done < <(profiles)
+    ;;
+  remove)
+    for p in "$HOME_DIR/.bashrc" "$HOME_DIR/.zshrc"; do
+      [[ -f "$p" ]] && grep -qxF "$BEGIN" "$p" || continue
+      tmp="$p.tftmp.$$"; strip "$p" > "$tmp"; cat "$tmp" > "$p"; rm -f "$tmp"
+      echo "tfyolo: removed from $p"
+    done
+    ;;
+  status)
+    found=0
+    for p in "$HOME_DIR/.bashrc" "$HOME_DIR/.zshrc"; do
+      [[ -f "$p" ]] && grep -qxF "$BEGIN" "$p" && { echo "tfyolo: in $p"; found=1; }
+    done
+    [[ $found -eq 1 ]] || echo "tfyolo: not installed (bash .tfcore/utils/tf-yolo-alias.sh install)"
+    ;;
+  *) echo "usage: tf-yolo-alias.sh install|remove|status" >&2; exit 2 ;;
+esac
+exit 0

package/.tfcore/utils/tf-yolo-perms.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""tf-yolo-perms.py — switch OpenCode to never ask, and back (owner, 2026-10-14). Run by tf-yolo.sh.
+
+    python3 .tfcore/utils/tf-yolo-perms.py on  <project-root>
+    python3 .tfcore/utils/tf-yolo-perms.py off <project-root>
+
+on   OpenCode: the config file it reads LAST (it reads opencode.json, opencode.jsonc,
+     .opencode/opencode.json, .opencode/opencode.jsonc, in that order, the last matching rule
+     winning; checked on OpenCode 2.0.27) is rewritten with every "ask" made "allow", every "deny"
+     kept in its place, and edit, webfetch, external_directory and doom_loop allowed, in the root map
+     and in every agent's. In a project that file is the framework's own .opencode/opencode.jsonc.
+     Its exact text is saved once, in .tfcore/.session/yolo-perms.json; a second `on` keeps the
+     first saving.
+     Claude Code is NOT switched here: it ignores permissions.defaultMode "bypassPermissions" in
+     project and local settings ("only policy/user/flag settings may grant bypass mode", Claude Code
+     2.1.299, 2026-10-14). Its side is the hook .tfcore/hooks/yolo-allow.sh, and for the prompts a
+     hook cannot clear (ask rules, safety checks), a session started with
+     `claude --permission-mode bypassPermissions` (tf-goal.sh always starts it so).
+off  Puts the OpenCode file back as it was (one the updater replaced meanwhile is left as the updater
+     wrote it) and removes the saving. Without a saving it does nothing.
+Exit 0 always: YOLO never fails a phase.
+"""
+import json
+import os
+import re
+import sys
+
+MARK = "// tf-yolo.sh on rewrote this file so nothing asks while YOLO is on; tf-yolo.sh off puts the original back"
+OPEN_ALLOW = ("edit", "webfetch", "external_directory", "doom_loop")
+
+
+def jsonc(text):
+    """JSON with // and /* */ comments and trailing commas, as opencode.jsonc is written"""
+    out, i, n, s = [], 0, len(text), None
+    while i < n:
+        c = text[i]
+        if s:
+            out.append(c)
+            if c == "\\" and i + 1 < n:
+                out.append(text[i + 1]); i += 2; continue
+            if c == s:
+                s = None
+        elif c == '"':
+            s = c; out.append(c)
+        elif text.startswith("//", i):
+            while i < n and text[i] != "\n":
+                i += 1
+            continue
+        elif text.startswith("/*", i):
+            j = text.find("*/", i + 2)
+            i = n if j < 0 else j + 2
+            continue
+        else:
+            out.append(c)
+        i += 1
+    return json.loads(re.sub(r",(\s*[}\]])", r"\1", "".join(out)))
+
+
+def never_ask(perm):
+    """a permission map with every "ask" made "allow"; order (and so every deny's place) kept"""
+    if perm == "ask":
+        return "allow"
+    if isinstance(perm, dict):
+        out = {k: never_ask(v) for k, v in perm.items()}
+        for k in OPEN_ALLOW:
+            if k not in out or out[k] == "ask":
+                out[k] = "allow"
+        return out
+    return perm
+
+
+def read(p):
+    try:
+        with open(p, encoding="utf-8") as f:
+            return f.read()
+    except OSError:
+        return None
+
+
+def write(p, text):
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    with open(p, "w", encoding="utf-8") as f:
+        f.write(text)
+
+
+def main(argv):
+    if len(argv) < 3 or argv[1] not in ("on", "off"):
+        print(__doc__)
+        return 0
+    verb, root = argv[1], argv[2]
+    saving = os.path.join(root, ".tfcore", ".session", "yolo-perms.json")
+    oc = next((os.path.join(root, *p) for p in ((".opencode", "opencode.jsonc"), (".opencode", "opencode.json"),
+                                                 ("opencode.jsonc",), ("opencode.json",))
+               if os.path.isfile(os.path.join(root, *p))), None)
+
+    if verb == "on":
+        if not os.path.isfile(saving):
+            write(saving, json.dumps({"opencode_file": oc, "opencode_text": read(oc) if oc else None}, indent=1))
+        # OpenCode
+        text = read(oc) if oc else None
+        if text is not None and MARK not in text:
+            try:
+                cfg = jsonc(text)
+            except ValueError:
+                cfg = None
+            if isinstance(cfg, dict):
+                cfg["permission"] = never_ask(cfg.get("permission") or {})
+                for a in (cfg.get("agent") or {}).values():
+                    if isinstance(a, dict) and a.get("permission"):
+                        a["permission"] = never_ask(a["permission"])
+                write(oc, MARK + "\n" + json.dumps(cfg, indent=2) + "\n")
+        print("permissions: OpenCode set to never ask; Claude Code: the yolo-allow hook")
+        return 0
+
+    # off
+    if not os.path.isfile(saving):
+        return 0
+    try:
+        before = json.loads(read(saving) or "{}")
+    except ValueError:
+        before = {}
+    oc_file, oc_text = before.get("opencode_file"), before.get("opencode_text")
+    if oc_file and oc_text is not None and MARK in (read(oc_file) or ""):
+        write(oc_file, oc_text)
+    os.remove(saving)
+    print("permissions: OpenCode config put back as it was")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main(sys.argv))
+    except Exception as e:   # never a veto
+        print(f"tf-yolo-perms: {e}", file=sys.stderr)
+        sys.exit(0)

package/.tfcore/utils/tf-yolo-start.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# tf-yolo-start.sh — what `tfyolo` runs: Claude Code in bypass mode with YOLO on (owner, 2026-10-14).
+#
+#   tfyolo                start a new Claude Code session here, nothing asks
+#   tfyolo -c             the same, continuing the last conversation in this folder (claude --continue)
+#   tfyolo <claude args>  any other claude arguments are passed through unchanged
+#
+# Why it exists: Claude Code drops its permission prompts only for a session STARTED in bypass mode
+# (`claude --permission-mode bypassPermissions`). Project settings cannot grant that mode (Claude Code
+# 2.1.299 ignores it there), and `*yolo` typed into an open session cannot switch it. So `tfyolo`
+# turns YOLO on (tf-yolo.sh on: the git-write ban stays, OpenCode stops asking too), starts Claude in
+# this terminal, and turns YOLO off again when that session ends, however it ends.
+#
+# It refuses outside a TechieFlow project: the hooks that keep git writes refused live in the
+# project, and bypass mode without them would let a commit through.
+# The `tfyolo` command itself is a shell function put in ~/.bashrc / ~/.zshrc by tf-yolo-alias.sh.
+# Exit: claude's own exit code; 2 when it could not start.
+
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+if [[ ! -f "$ROOT/.tfcore/hooks/block-git.sh" || ! -f "$ROOT/.claude/settings.json" ]]; then
+  echo "tfyolo: $ROOT is not a TechieFlow project with its Claude Code hooks (no .tfcore/hooks/block-git.sh or .claude/settings.json); not starting in bypass mode." >&2
+  exit 2
+fi
+grep -q 'block-git.sh' "$ROOT/.claude/settings.json" 2>/dev/null || {
+  echo "tfyolo: $ROOT/.claude/settings.json does not register block-git.sh, so git writes would not be refused; run update-framework.sh on this project first." >&2
+  exit 2
+}
+CLAUDE_BIN="${TF_CLAUDE_BIN:-$(command -v claude 2>/dev/null)}"
+[[ -n "$CLAUDE_BIN" ]] || { echo "tfyolo: the claude command is not on PATH" >&2; exit 2; }
+
+export CLAUDE_PROJECT_DIR="$ROOT"
+bash "$HERE/tf-yolo.sh" on --source tfyolo >/dev/null
+off() { CLAUDE_PROJECT_DIR="$ROOT" bash "$HERE/tf-yolo.sh" off >/dev/null 2>&1; }
+trap 'off' EXIT
+trap 'off; exit 130' INT TERM
+
+echo "tfyolo: YOLO on, Claude Code starting in bypass mode in $ROOT (git writes stay refused; YOLO goes off when this session ends)"
+cd "$ROOT" || exit 2
+"$CLAUDE_BIN" --permission-mode bypassPermissions "$@"
+rc=$?
+echo "tfyolo: session ended; YOLO off"
+exit $rc

package/.tfcore/utils/tf-yolo.sh

@@ -8,6 +8,26 @@
 #   bash .tfcore/utils/tf-yolo.sh done [complete|blocked] ["<summary>"]   goal finished → write the sentinel
 #                                                                         the tf-goal.sh supervisor stops on
 #   bash .tfcore/utils/tf-yolo.sh clear-done                              remove the sentinel (supervisor does this)
+#   bash .tfcore/utils/tf-yolo.sh sync                                    put the harness permissions back when
+#                                                                         the flag has gone or expired (hooks call it)
+#
+# YOLO NEVER ASKS (owner, 2026-10-14: "if it's still asking for permission, what's the purpose of
+# YOLO mode?"). While the flag is live both harnesses stop asking, and `off`, `done` and an expired
+# flag put them back:
+#   - Claude Code: the hook .tfcore/hooks/yolo-allow.sh approves every tool call, in the session
+#     already running. Claude Code still asks where a hook's allow is not enough — an ask rule or one
+#     of its own safety checks ("requires the full permission pipeline") — and it refuses bypass mode
+#     from project or local settings ("only policy/user/flag settings may grant bypass mode"; both
+#     seen in its debug log, 2.1.299, 2026-10-14). Those prompts go only in a session started with
+#     `claude --permission-mode bypassPermissions`, which tf-goal.sh always uses.
+#   - OpenCode: the config file it reads last (.opencode/opencode.jsonc in a project) is rewritten
+#     with each "ask" turned to "allow" and every deny kept, and edits, web fetches, folders outside
+#     the project and repeated calls allowed; `off` puts its exact text back. OpenCode reads it when
+#     a session starts; the plugin's permission.ask approves everything while the flag is live
+#     (OpenCode 1.x).
+# Version-control WRITES stay refused in both: the deny rules are kept, and block-git.sh refuses
+# them before any permission check. What each file held before is kept under .tfcore/.session/ and
+# restored exactly.
 #
 # YOLO is ON when ANY of these holds (checked in this order by block-git.sh too):
 #   1. env TF_YOLO=1                      (tf-goal.sh exports it for the whole run)
@@ -54,6 +74,8 @@ flag_live() {  # exit 0 = flag present AND not expired
   [[ -n "$(find "$FLAG" -mmin "+$(( TTL_HOURS * 60 ))" 2>/dev/null)" ]] && return 1
   return 0
 }
+PERM_PY="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/tf-yolo-perms.py"
+perms() { python3 "$PERM_PY" "$1" "$ROOT" 2>/dev/null || true; }   # on | off; never fails the caller
 json_escape() { printf '%s' "$1" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "${1//\"/\\\"}"; }
 
 cmd="${1:-status}"; shift || true
@@ -74,11 +96,16 @@ case "$cmd" in
         "$(now_utc)" "$(json_escape "$SOURCE")" "$(json_escape "$GOAL")" "$(json_escape "${TF_HARNESS:-claude-code}")"
     } > "$FLAG" 2>/dev/null || true
     rm -f "$DONE" 2>/dev/null || true
-    echo "YOLO: ON (source=$SOURCE) — no confirmations; deletes + read-only git allowed; git WRITES still blocked; run to completion."
+    perms on
+    echo "YOLO: ON (source=$SOURCE) — no confirmations; OpenCode never asks (from its next session); Claude Code approves every call it can (its own safety checks still ask unless the session was started with: claude --permission-mode bypassPermissions); deletes + read-only git allowed; git WRITES still blocked; run to completion."
     ;;
   off)
     rm -f "$FLAG" 2>/dev/null || true
-    echo "YOLO: OFF — back to ask-on-delete, no-git, confirm-at-phase-boundaries."
+    perms off
+    echo "YOLO: OFF — back to ask-on-delete, no-git, confirm-at-phase-boundaries; OpenCode's asks restored."
+    ;;
+  sync)
+    if [[ "${TF_YOLO:-0}" == "1" ]] || flag_live; then :; else perms off; fi
     ;;
   is-on)
     if [[ "${TF_YOLO:-0}" == "1" ]] || flag_live; then exit 0; else exit 1; fi
@@ -166,13 +193,14 @@ PY2
     # unprompted and read-only git open and nothing on screen saying so. The
     # supervisor reads $DONE, never $FLAG, so clearing it here stops nothing.
     rm -f "$FLAG" 2>/dev/null || true
+    perms off
     echo "GOAL-DONE ($OUTCOME) recorded at $DONE — the supervisor (tf-goal.sh) will stop. YOLO flag cleared."
     ;;
   clear-done)
     rm -f "$DONE" 2>/dev/null || true
     ;;
   *)
-    echo "usage: tf-yolo.sh on|off|status|is-on|done [complete|blocked] [summary]|clear-done" >&2
+    echo "usage: tf-yolo.sh on|off|status|is-on|done [complete|blocked] [summary]|clear-done|sync" >&2
     ;;
 esac
 exit 0