wizz-method 2.0.0 → 2.1.0

package/src/scripts/memlog.js

@@ -0,0 +1,368 @@
+/**
+ * memlog — an append-only memory log: LLM-optimal working memory for a skill.
+ *
+ * A memlog is the dense, chronological record of everything that mattered in a piece of
+ * work — every item the user generated or accepted — kept minimal like human memory: only
+ * what's important, never bloated. It persists ACROSS sessions, so a fresh session can
+ * load it and continue. It is NOT a deliverable; downstream artifacts (a brief, a PRD, a
+ * deck, a report) are *derived* from it on demand. The host skill supplies the vocabulary
+ * by how it calls `append` — the tool stays neutral.
+ *
+ * It is a FLAT log: there are no sections or grouping. Every entry is one line, recorded
+ * at the END in the order it happened. The chronology itself is the structure — an event
+ * like "started technique X" is just another entry, same as an idea or an insight.
+ *
+ * Three invariants make it trustworthy:
+ *
+ *   1. Append-only, chronological. Entries land at the end, in the order they happen.
+ *      Nothing is ever inserted backward, reordered, edited, or removed. There is no
+ *      edit or delete subcommand by design; history is never rewritten.
+ *   2. Write-only / blind. Every command is an atomic, context-free write and echoes the
+ *      new state as one line of JSON, so the caller never re-reads the file mid-session.
+ *      The one time the file is read is on resume — and the caller reads it itself, not
+ *      via this script.
+ *   3. No lifecycle status. A memory log has no "complete" flag. Whether the work is done,
+ *      blocked, or paused is itself a fact that happened, so it is recorded as an entry
+ *      (e.g. `append --type event --text "session complete"`), never as frontmatter the
+ *      log would have to mutate.
+ *
+ * Atomicity: every write goes to a temp file, is flushed and fsync'd, then atomically
+ * renamed over the target, so a crash never leaves a half-written entry. Concurrent
+ * writers serialize on an O_EXCL lock file next to the memlog.
+ *
+ * Known limitation (by design, not a bug): there is no compaction, archival, or size
+ * cap. Append-only + no lifecycle status (invariant 3 above) means a `.memlog.md` grows
+ * without bound for the life of the workspace. If that ever becomes a real problem, the
+ * fix is a new host-skill-driven step, not a change to this script's invariants.
+ *
+ * The file shape (.memlog.md):
+ *
+ *     ---
+ *     topic: Onboarding flow for a budgeting app
+ *     goal: lift week-1 retention
+ *     updated: 2026-06-07T14:22
+ *     ---
+ *
+ *     - (note) user picked techniques: SCAMPER, then Six Thinking Hats
+ *     - (technique) started SCAMPER
+ *     - (idea) skip the signup wall: let people try with sample data first
+ *     - (event) session complete
+ *
+ * Each entry may carry an optional `--type` — what KIND it is (idea, insight, question,
+ * decision, direction, assumption, gap, note, event, …) — and an optional `--by` naming
+ * who it came from (e.g. `user`, `coach`). Both render into one short inline tag:
+ * `(idea)`, `(idea by user)`, `(by coach)`. Omit them for a plain note. The host skill
+ * names the vocabulary; the script does not enforce one.
+ *
+ * Commands:
+ *   init   (--workspace DIR | --path FILE) [--field k=v ...]               create the memlog (errors if it exists)
+ *   append (--workspace DIR | --path FILE) --text STR [--type T] [--by W]  append one entry at the end
+ *   set    (--workspace DIR | --path FILE) --key K --value V               set/replace a frontmatter field
+ *
+ * Addressing: `--workspace` is the run folder, and the memlog is always
+ * {workspace}/.memlog.md. `--path` points straight at the memlog file instead.
+ *
+ * Zero dependencies on purpose: this file is copied verbatim to
+ * `{project-root}/_wizz/scripts/memlog.js` at install time, where there is no
+ * node_modules of any kind. Only `node:*` builtins may be required here.
+ *
+ * Node port of the former memlog.py (audit item 29, 2026-09-12): Node is now the only
+ * prerequisite of the Wizz core.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MEMLOG = '.memlog.md';
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_MS = 50;
+// A lock older than this belonged to a process that died mid-write; reclaim it
+// instead of making every later caller wait out the full timeout.
+const LOCK_STALE_MS = 30_000;
+
+const EXIT_OK = 0;
+const EXIT_RUNTIME = 1;
+const EXIT_USAGE = 2;
+
+// ─── helpers ───
+
+/** Local timestamp in the frontmatter's `updated` format (YYYY-MM-DDTHH:MM). */
+function now() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+/** Block the current thread for `ms` without a dependency and without a busy spin. */
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/** Python's str.splitlines(): split on newlines and drop the empty tail a final \n leaves. */
+function splitLines(text) {
+  const lines = text.split(/\r\n|\n|\r/);
+  if (lines.at(-1) === '') lines.pop();
+  return lines;
+}
+
+// ─── locking ───
+
+/**
+ * Take an exclusive lock on `lockFile` (O_EXCL create), retrying until LOCK_TIMEOUT_MS.
+ * @param {string} lockFile
+ * @returns {number} open file descriptor for the lock
+ */
+function acquireLock(lockFile) {
+  fs.mkdirSync(path.dirname(lockFile), { recursive: true });
+  const start = Date.now();
+  while (Date.now() - start < LOCK_TIMEOUT_MS) {
+    try {
+      return fs.openSync(lockFile, 'wx');
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      reclaimIfStale(lockFile);
+      sleepSync(LOCK_RETRY_MS);
+    }
+  }
+  throw new Error(
+    `Falha ao adquirir lock de ${lockFile} após ${LOCK_TIMEOUT_MS / 1000}s. ` + 'Outro processo pode estar gravando o arquivo de memória.',
+  );
+}
+
+/** Delete a lock left behind by a crashed writer (older than LOCK_STALE_MS). */
+function reclaimIfStale(lockFile) {
+  try {
+    if (Date.now() - fs.statSync(lockFile).mtimeMs > LOCK_STALE_MS) fs.unlinkSync(lockFile);
+  } catch {
+    // Gone already, or not ours to clean up: the retry loop handles both.
+  }
+}
+
+/** Release the lock: close the descriptor and remove the lock file. */
+function releaseLock(fd, lockFile) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+    // Already closed.
+  }
+  try {
+    fs.unlinkSync(lockFile);
+  } catch {
+    // Another writer already reclaimed it as stale.
+  }
+}
+
+// ─── file shape ───
+
+/** The memlog file, from either addressing mode: {workspace}/.memlog.md or an explicit --path. */
+function resolveTarget(args) {
+  return args.path ? path.normalize(args.path) : path.join(args.workspace, MEMLOG);
+}
+
+/**
+ * Return [frontmatter Map in source order, body string]. Frontmatter is plain key: value.
+ * The closing fence is the first line that is *exactly* `---`, so a `---` inside a field
+ * value (topic/goal are free user text) never truncates the frontmatter.
+ * @param {string} text
+ * @returns {[Map<string, string>, string]}
+ */
+function split(text) {
+  const lines = splitLines(text);
+  if (lines.length === 0 || lines[0] !== '---') throw new Error('.memlog.md has no frontmatter');
+  const end = lines.findIndex((line, i) => i >= 1 && line === '---');
+  if (end === -1) throw new Error('.memlog.md frontmatter is not terminated');
+  const meta = new Map();
+  for (const line of lines.slice(1, end)) {
+    const at = line.indexOf(':');
+    if (at === -1) continue;
+    meta.set(line.slice(0, at).trim(), line.slice(at + 1).trim());
+  }
+  return [
+    meta,
+    lines
+      .slice(end + 1)
+      .join('\n')
+      .replace(/^\n+/, ''),
+  ];
+}
+
+/**
+ * Render frontmatter + body back to the file shape.
+ * Newlines in values are neutralized so a multi-line field can't break the fence on re-read.
+ */
+function render(meta, body) {
+  const fm = [...meta].map(([k, v]) => `${k}: ${splitLines(String(v)).join(' ')}`).join('\n');
+  return `---\n${fm}\n---\n\n${body.replace(/\n+$/, '')}\n`;
+}
+
+/** Stamp `updated` and keep it last so the field order stays predictable. */
+function touch(meta) {
+  meta.delete('updated');
+  meta.set('updated', now());
+}
+
+/** Temp + write + fsync + atomic rename, so a crash never half-writes an entry. */
+function writeAtomic(target, text) {
+  const tmp = `${target}.tmp`;
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeFileSync(fd, text, 'utf8');
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, target);
+}
+
+function entryCount(body) {
+  return splitLines(body).filter((line) => line.startsWith('- ')).length;
+}
+
+/** Echo new state so the caller never re-reads the file to know where it stands. */
+function ack(target, body) {
+  process.stdout.write(`${JSON.stringify({ ok: true, memlog: target, entries: entryCount(body) })}\n`);
+}
+
+/** Read and parse the memlog, turning a missing file into a friendly usage error. */
+function readMemlog(target) {
+  let text;
+  try {
+    text = fs.readFileSync(target, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new UsageError(`${target} does not exist; run \`init\` before append/set`);
+    }
+    throw new Error(`failed to read ${target}: ${error.message}`);
+  }
+  return split(text);
+}
+
+// ─── commands ───
+
+class UsageError extends Error {}
+
+function cmdInit(args) {
+  const target = resolveTarget(args);
+  if (fs.existsSync(target)) {
+    throw new UsageError(`${target} already exists; use append/set to update it`);
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const meta = new Map();
+  for (const pair of args.field) {
+    const at = pair.indexOf('=');
+    if (at === -1) throw new UsageError(`--field expects key=value, got '${pair}'`);
+    meta.set(pair.slice(0, at).trim(), pair.slice(at + 1).trim());
+  }
+  touch(meta);
+  writeAtomic(target, render(meta, ''));
+  ack(target, '');
+  return EXIT_OK;
+}
+
+/** Build one entry line: `- (type by who) text`, with the tag omitted when both are absent. */
+function entryLine(args) {
+  const text = args.text.trim().split(/\s+/).filter(Boolean).join(' ');
+  let label = args.type || '';
+  if (args.by) label = `${label} by ${args.by}`.trim(); // attribution: "(idea by user)" / "(by coach)"
+  return `- ${label ? `(${label}) ` : ''}${text}`;
+}
+
+/** Run `mutate(meta, body)` under the lock and write the result atomically. */
+function withLockedMemlog(target, mutate) {
+  const lockFile = `${target}.lock`;
+  const fd = acquireLock(lockFile);
+  try {
+    const [meta, body] = readMemlog(target);
+    const nextBody = mutate(meta, body);
+    touch(meta);
+    writeAtomic(target, render(meta, nextBody));
+    ack(target, nextBody);
+    return EXIT_OK;
+  } finally {
+    releaseLock(fd, lockFile);
+  }
+}
+
+function cmdAppend(args) {
+  const target = resolveTarget(args);
+  return withLockedMemlog(target, (_meta, body) => {
+    const entry = entryLine(args);
+    return body.trim() ? `${body.replace(/\n+$/, '')}\n${entry}` : entry; // always at the end
+  });
+}
+
+function cmdSet(args) {
+  const target = resolveTarget(args);
+  return withLockedMemlog(target, (meta, body) => {
+    meta.set(args.key, args.value);
+    return body;
+  });
+}
+
+// ─── CLI ───
+
+const COMMANDS = {
+  init: { run: cmdInit, flags: { field: 'many' }, required: [] },
+  append: { run: cmdAppend, flags: { text: 'one', type: 'one', by: 'one' }, required: ['text'] },
+  set: { run: cmdSet, flags: { key: 'one', value: 'one' }, required: ['key', 'value'] },
+};
+
+const USAGE = 'usage: memlog.js {init,append,set} (--workspace DIR | --path FILE) [options]';
+
+/**
+ * Parse argv for one subcommand. Throws UsageError on anything argparse would reject.
+ * @param {string[]} argv
+ * @returns {{spec: object, args: object}}
+ */
+function parseArgs(argv) {
+  const [name, ...rest] = argv;
+  const spec = Object.prototype.hasOwnProperty.call(COMMANDS, name) ? COMMANDS[name] : null;
+  if (!spec) throw new UsageError(`invalid choice: '${name ?? ''}' (choose from init, append, set)`);
+  const flags = { workspace: 'one', path: 'one', ...spec.flags };
+  const args = { field: [] };
+  for (let i = 0; i < rest.length; i++) {
+    const key = rest[i].startsWith('--') ? rest[i].slice(2) : null;
+    const kind = key && Object.prototype.hasOwnProperty.call(flags, key) ? flags[key] : null;
+    if (!kind) throw new UsageError(`unrecognized argument: ${rest[i]}`);
+    const value = rest[++i];
+    if (value === undefined) throw new UsageError(`argument --${key}: expected one argument`);
+    if (kind === 'many') args[key].push(value);
+    else args[key] = value;
+  }
+  // Mutually exclusive AND required: exactly one of the two must be present.
+  if (Boolean(args.workspace) === Boolean(args.path)) {
+    throw new UsageError('one of the arguments --workspace --path is required (and not both)');
+  }
+  for (const required of spec.required) {
+    if (args[required] === undefined) throw new UsageError(`the following arguments are required: --${required}`);
+  }
+  return { spec, args };
+}
+
+/**
+ * Entry point. Returns the process exit code instead of throwing, so callers
+ * (tests included) can assert on it.
+ * @param {string[]} argv - argv without node and script
+ * @returns {number}
+ */
+function main(argv) {
+  try {
+    const { spec, args } = parseArgs(argv);
+    return spec.run(args);
+  } catch (error) {
+    if (error instanceof UsageError) {
+      process.stderr.write(`${USAGE}\nerror: ${error.message}\n`);
+      return EXIT_USAGE;
+    }
+    process.stderr.write(`error: ${error.message}\n`);
+    return EXIT_RUNTIME;
+  }
+}
+
+if (require.main === module) {
+  process.exitCode = main(process.argv.slice(2));
+}
+
+module.exports = { main, split, render, entryCount, MEMLOG };

package/src/scripts/resolve_customization.py

@@ -46,6 +46,20 @@ Optional `include` (aditivo, opcional):
   include files warn to stderr and are skipped (fail-open, matching the
   rest of this resolver); they never abort resolution. A toml with no
   `include` key resolves exactly as before this feature existed.
+
+  `_shared/` fallback: after `wizz install` the skill directory is moved
+  out of `_wizz/` into the IDE folder (`.claude/skills/<skill>/`), so a
+  shipped `include = ["../../_shared/x.md"]` no longer resolves. When the
+  base-relative path is missing AND the include mentions `_shared/`, the
+  segment after the LAST `_shared/` is looked up under
+  `<project-root>/_wizz/<module>/_shared/` for every module that has one,
+  modules sorted by name, first hit wins.
+
+  Containment: when a project root is known, an include whose base-relative
+  path escapes that root (`../../../../outside.md`) is refused with a warning
+  before it is read. The `_shared/` fallback candidates live under
+  `<project-root>/_wizz/` by construction, so they always pass. A standalone
+  skill with no resolvable project root keeps the unrestricted behaviour.
 """
 
 import argparse
@@ -67,6 +81,8 @@ except ImportError:
 
 _MISSING = object()
 _KEYED_MERGE_FIELDS = ("code", "id")
+_WIZZ_FOLDER_NAME = "_wizz"
+_SHARED_DIR_NAME = "_shared"
 
 
 def find_project_root(start: Path):
@@ -114,19 +130,90 @@ _INCLUDE_TARGET_FIELD = "activation_steps_append"
 
 def _read_include_file(path: Path):
     """Read an include file's raw text. Returns None (and warns to stderr)
-    when the file is missing or unreadable, so a broken/renamed include
-    never aborts resolution — same fail-open philosophy as the optional
-    team/user layers above."""
-    if not path.is_file():
-        sys.stderr.write(f"warning: include not found, skipping: {path}\n")
-        return None
+    when the file is unreadable, so a broken include never aborts
+    resolution — same fail-open philosophy as the optional team/user layers
+    above. Existence (and the `_shared/` fallback) is `_find_include_file`'s
+    job."""
     try:
         return path.read_text(encoding="utf-8")
     except OSError as error:
-        sys.stderr.write(f"warning: failed to read include {path}: {error}\n")
+        sys.stderr.write(f"warning: include not readable, skipping: {path}: {error}\n")
         return None
 
 
+def _shared_fallback_candidates(rel_path: str, project_root):
+    """Absolute candidates for an include whose base-relative path is missing.
+
+    The verbatim install pipeline moves each skill directory OUT of `_wizz/`
+    into the IDE folder (`.claude/skills/<skill>/customize.toml`) while the
+    file keeps its shipped `include = ["../../_shared/x.md"]`. From there that
+    resolves to `.claude/_shared/x.md`, which does not exist, and every
+    included paragraph was dropped silently. The real shared files live at
+    `<project-root>/_wizz/<module>/_shared/`. So: take the segment after the
+    LAST `_shared/` in the include and look for it under every module directly
+    under `_wizz/` that has a `_shared/` folder, modules sorted by name (first
+    hit wins upstream). Nothing else is guessed: an include without `_shared/`
+    gets no fallback. Mirror of `sharedFallbackCandidates` in
+    tools/installer/core/resolved-includes.js."""
+    if project_root is None or not isinstance(rel_path, str):
+        return []
+    posix = rel_path.replace("\\", "/")
+    marker = _SHARED_DIR_NAME + "/"
+    index = posix.rfind(marker)
+    if index == -1:
+        return []
+    segment = posix[index + len(marker):]
+    parts = segment.split("/")
+    if not segment or any(part in ("", "..", ".") for part in parts):
+        return []
+
+    wizz_root = project_root / _WIZZ_FOLDER_NAME
+    try:
+        modules = sorted(entry.name for entry in wizz_root.iterdir() if entry.is_dir())
+    except OSError:
+        return []
+    candidates = []
+    for name in modules:
+        shared_dir = wizz_root / name / _SHARED_DIR_NAME
+        if not shared_dir.is_dir():
+            continue
+        candidates.append(shared_dir.joinpath(*parts))
+    return candidates
+
+
+def _is_outside_project_root(base_dir: Path, rel_path: str, project_root):
+    """True when the base-relative include escapes the project root.
+
+    Hardening (2026-09-11): a customize.toml must not pull arbitrary files
+    from the user's home or from a sibling checkout into an agent's
+    activation steps, so `include = ["../../../../outside.md"]` is refused
+    before it is ever read. The `_shared/` fallback candidates are built
+    under `<project-root>/_wizz/` by construction and always pass. When no
+    project root is resolvable (standalone skill) there is nothing to be
+    outside of and the old unrestricted behaviour stands. Mirror of
+    `isOutsideProjectRoot` in tools/installer/core/resolved-includes.js."""
+    if project_root is None:
+        return False
+    primary = (base_dir / rel_path).resolve()
+    try:
+        primary.relative_to(Path(project_root).resolve())
+    except ValueError:
+        return True
+    return False
+
+
+def _find_include_file(base_dir: Path, rel_path: str, project_root):
+    """Absolute path the include actually points at, or None. Base-relative
+    first, then the `_shared/` fallback above."""
+    primary = (base_dir / rel_path).resolve()
+    if primary.is_file():
+        return primary
+    for candidate in _shared_fallback_candidates(rel_path, project_root):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
 def _split_include_paragraphs(text: str):
     """Split an included markdown file into instruction strings.
 
@@ -144,7 +231,7 @@ def _split_include_paragraphs(text: str):
     return paragraphs
 
 
-def resolve_includes(data, base_dir: Path):
+def resolve_includes(data, base_dir: Path, project_root=None, skill_name: str = ""):
     """Expand `include = [...]` keys found in any table of `data`.
 
     Purely additive: a table without `include` comes back unchanged. When
@@ -163,7 +250,22 @@ def resolve_includes(data, base_dir: Path):
             if not isinstance(rel_path, str):
                 sys.stderr.write(f"warning: include entries must be strings, got: {rel_path!r}\n")
                 continue
-            text = _read_include_file((base_dir / rel_path).resolve())
+            if _is_outside_project_root(base_dir, rel_path, project_root):
+                sys.stderr.write(
+                    f'warning: include outside the project root, skipping: "{rel_path}" '
+                    f"(skill: {skill_name or '?'})\n"
+                )
+                continue
+            target = _find_include_file(base_dir, rel_path, project_root)
+            if target is None:
+                primary = (base_dir / rel_path).resolve()
+                sys.stderr.write(
+                    f'warning: include not found, skipping: "{rel_path}" '
+                    f"(skill: {skill_name or '?'}; tried {primary} and every "
+                    f"{_WIZZ_FOLDER_NAME}/*/{_SHARED_DIR_NAME}/)\n"
+                )
+                continue
+            text = _read_include_file(target)
             if text is not None:
                 included_paragraphs.extend(_split_include_paragraphs(text))
     elif "include" in data:
@@ -173,7 +275,9 @@ def resolve_includes(data, base_dir: Path):
     for key, value in data.items():
         if key == "include":
             continue
-        result[key] = resolve_includes(value, base_dir) if isinstance(value, dict) else value
+        result[key] = (
+            resolve_includes(value, base_dir, project_root, skill_name) if isinstance(value, dict) else value
+        )
 
     if included_paragraphs:
         existing = result.get(_INCLUDE_TARGET_FIELD, [])
@@ -294,20 +398,25 @@ def main():
     skill_name = skill_dir.name
     defaults_path = skill_dir / "customize.toml"
 
-    defaults = resolve_includes(load_toml(defaults_path, required=True), defaults_path.parent)
-
     # Prefer the project that contains this skill. Only fall back to cwd if
     # the skill isn't inside a recognizable project tree (unusual but possible
     # for standalone skills invoked directly). Using cwd first is unsafe when
     # an ancestor of cwd happens to have a stray _wizz/ from another project.
+    # Resolved BEFORE the base layer: the `_shared/` include fallback needs it.
     project_root = find_project_root(skill_dir) or find_project_root(Path.cwd())
 
+    defaults = resolve_includes(
+        load_toml(defaults_path, required=True), defaults_path.parent, project_root, skill_name
+    )
+
     team = {}
     user = {}
     if project_root:
-        custom_dir = project_root / "_wizz" / "custom"
-        team = resolve_includes(load_toml(custom_dir / f"{skill_name}.toml"), custom_dir)
-        user = resolve_includes(load_toml(custom_dir / f"{skill_name}.user.toml"), custom_dir)
+        custom_dir = project_root / _WIZZ_FOLDER_NAME / "custom"
+        team = resolve_includes(load_toml(custom_dir / f"{skill_name}.toml"), custom_dir, project_root, skill_name)
+        user = resolve_includes(
+            load_toml(custom_dir / f"{skill_name}.user.toml"), custom_dir, project_root, skill_name
+        )
 
     merged = deep_merge(defaults, team)
     merged = deep_merge(merged, user)

package/src/skills-lib/_shared/complexity-signal.md

@@ -0,0 +1,14 @@
+# Sinal de complexidade (fonte única)
+#
+# Lido por wizz-router (SKILL.md), wizz-maestro (SKILL.md) e wizz-quick-dev
+# (SKILL.md) como a FONTE CANÔNICA do parágrafo de regra abaixo. As SKILL.md
+# não fazem include automático dele (skills são pastas autocontidas copiadas
+# verbatim), então editar aqui NÃO propaga sozinho — quem editar este
+# parágrafo precisa replicar a mudança manualmente nas 3 SKILL.md (PT-BR
+# idêntico (após a normalização do teste: backticks, prefixo wizz-, "(você)") em wizz-router/wizz-maestro; tradução em inglês em
+# wizz-quick-dev). `test/test-dispatch-rule-consistency.js` compara o texto
+# do bloco (não só os números) contra as 3 cópias e falha em qualquer
+# divergência de wording, não só de limiar.
+# ---
+
+Regra de dispatch: SE 2+ áreas → maestro, sempre. SENÃO conte os 3 fatores restantes (multi-passo, precisa planejar, gera artefato memorável); 2+ fatores → maestro. A cláusula de área decide sozinha, sem somar com mais nada.

package/src/skills-lib/wizz-canvas-design/canvas-fonts/InstrumentSerif-OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Instrument Serif Project Authors (https://github.com/Instrument/instrument-serif)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/skills-lib/wizz-huashu-design/references/sfx-library.md

@@ -12,7 +12,7 @@
 > 仓库和已下载的缓存中）。用某个 SFX 前先 `ls assets/sfx/<category>/` 确认文件存在；
 > 缺失就跑 `npx --yes wizz-method fetch-assets --bundle huashu-audio --dest
 > assets`（路径相对本 skill 根目录）。离线时手动下载
-> `https://github.com/wizzcomms/wizz-method/releases/download/assets-v1/huashu-audio.tar.gz`
+> `npx wizz-method fetch-assets --bundle huashu-audio` (2 partes em `https://wizz-assets.junior-aec.workers.dev/huashu-audio-1.tar.gz` e `.../huashu-audio-2.tar.gz`)
 > 解压到 `assets/`，能力不受影响，只是首次用要等下载。
 
 ---