@ericrisco/rsc 0.1.33 → 0.1.35

package/skills/marketing/references/brand-grounding.md

@@ -91,9 +91,19 @@ If the user can't answer a question, that dimension stays incomplete — note th
 
 ### Brand wiki article template
 
-Each `02-DOCS/wiki/brand/*.md` article follows the harness wiki format:
+Each `02-DOCS/wiki/brand/*.md` article follows the harness wiki format. It is an OKF v0.1 article: open it with YAML frontmatter carrying a non-empty `type:` (`brand-study`), then the H1 and body:
 
 ```markdown
+---
+type: brand-study
+title: Brand — Value Proposition
+description: The core benefit and what makes this brand different from the named alternatives.
+tags: [brand, value-proposition]
+timestamp: YYYY-MM-DDTHH:MM:SSZ
+topic: brand
+status: stable
+---
+
 # Brand — Value Proposition
 
 > Sources: {user interview, YYYY-MM-DD}
@@ -124,9 +134,19 @@ One paragraph: the core benefit and what makes it different.
 
 ### Voice article specifics
 
-`voice.md` must contain the do/don't word lists and link to every raw sample:
+`voice.md` must contain the do/don't word lists and link to every raw sample (same OKF frontmatter; `type: brand-study`):
 
 ```markdown
+---
+type: brand-study
+title: Brand — Tone & Voice
+description: Tone descriptors, do/don't word lists, and the voice fingerprint extracted from real samples.
+tags: [brand, voice, tone]
+timestamp: YYYY-MM-DDTHH:MM:SSZ
+topic: brand
+status: stable
+---
+
 # Brand — Tone & Voice
 
 > Sources: {user interview, YYYY-MM-DD}

package/skills/medium-strategy/SKILL.md

@@ -133,6 +133,16 @@ On a monthly/quarterly review:
 Every session ends with a dated record under `02-DOCS/wiki/medium/decisions/`. Minimum fields — the bet-on metric is mandatory, because a decision with no metric is an opinion, not a checkable bet:
 
 ```markdown
+---
+type: medium-decision
+title: Solo vs publication for AI-tools series
+description: Stay solo + canonical-import the blog series; pitch one Boost-eligible AI pub with a native original.
+tags: [medium, publications, monetization, distribution]
+timestamp: 2026-06-02T00:00:00Z
+topic: medium
+status: stable
+---
+
 # 2026-06-02 — Solo vs publication for AI-tools series
 
 Decision: Stay solo profile + canonical-import the blog series; pitch one Boost-eligible AI pub with a native original.
@@ -140,6 +150,8 @@ Rationale: 400 followers, no editor nomination path; the blog has evergreen sear
 Bets on metric: member reading time from external/search referral; 1 Boost nomination this quarter.
 ```
 
+`type:` is the required OKF v0.1 field; `timestamp` is ISO 8601. The `Decision:` / `Bets on metric:` lines are domain signals `verify.sh` greps for — keep them.
+
 After a review, append a `what-worked.md` entry tied to specific stories/pubs/tags (e.g. "`AI Coding Tools` long-tail + Boost → 3.2h member reading time"). Full templates, layout, and the verify.sh contract: [`references/wiki-records.md`](references/wiki-records.md). Sanity-check the wiki with `scripts/verify.sh 02-DOCS/wiki/medium/`.
 
 ## Anti-patterns

package/skills/medium-strategy/references/wiki-records.md

@@ -2,6 +2,8 @@
 
 This is the persistence layer that makes medium-strategy compound. Read SKILL.md §1 and §9 first; this file is the exact format.
 
+Every `.md` file written under `02-DOCS/wiki/medium/` is part of the OKF v0.1 bundle: it carries YAML frontmatter with a non-empty `type:` (the only required OKF field), and any cross-references use **standard markdown links** (`[Text](./pubs.md)`), never wikilinks (`[[...]]`). The domain lines `verify.sh` greps for (the dated heading, `Decision:`, the metric/bet field) stay exactly as shown below.
+
 ## Layout under `02-DOCS/wiki/medium/`
 
 ```text
@@ -21,6 +23,16 @@ This is the persistence layer that makes medium-strategy compound. Read SKILL.md
 Every decision file MUST carry three signals: a **date**, a **Decision:** line, and a **named metric/bet**. The metric is mandatory — a decision with no metric is an opinion, not something you can check next quarter.
 
 ```markdown
+---
+type: medium-decision
+title: Solo vs publication for the AI-tools series
+description: Stay solo; canonical-import the evergreen blog posts; pitch one Boost-eligible AI pub.
+tags: [medium, publications, monetization, distribution]
+timestamp: 2026-06-02T00:00:00Z
+topic: medium
+status: stable
+---
+
 # 2026-06-02 — Solo vs publication for the AI-tools series
 
 Decision: Stay solo profile; canonical-import the 6 evergreen blog posts; pitch one Boost-eligible AI publication with a new native original.
@@ -29,11 +41,23 @@ Bets on metric: member reading time from external + search referral over 90 days
 Status: open
 ```
 
-When the bet resolves, append a short outcome to the same file (`Status: won — Boost nomination 2026-07; +2.1h member reading time`) rather than editing the original — append-only history.
+`type:` (required) + `timestamp:` (ISO 8601, last meaningful edit) are the OKF surface; the `Status:` line in the body is the domain bet-lifecycle marker — distinct from the frontmatter `status:` (the OKF article lifecycle: draft | stable | stale). When the bet resolves, append a short outcome to the body (`Status: won — Boost nomination 2026-07; +2.1h member reading time`) rather than editing the original — append-only history. A running `decisions.md` log at the root carries one frontmatter block at the top (`type: medium-decision`).
 
 ## what-worked.md entry template
 
+`what-worked.md` is one running file; new review blocks are prepended newest-first under a single frontmatter block at the top.
+
 ```markdown
+---
+type: medium-record
+title: What worked — Medium
+description: Running log of outcomes tied to specific Medium stories, publications, and tags.
+tags: [medium, what-worked, member-reading-time, boost]
+timestamp: 2026-09-01T00:00:00Z
+topic: medium
+status: stable
+---
+
 ## 2026-09-01 — Q3 review
 - `AI Coding Tools` (long-tail) + Boost → 3.2h member reading time on one story. Double down: keep the long-tail tag, pitch the same pub again.
 - Imported blog post w/ canonical + newsletter push → +5% external bonus visible, but low member conversion. Keep importing; stop expecting member reads from cold list.
@@ -44,6 +68,20 @@ When the bet resolves, append a short outcome to the same file (`Status: won —
 
 Keep these lightweight. `pubs.md`: pub name | status (accepted/pitched/dropped) | niche fit | a one-line guideline note. `tags.md`: tag | popular-or-long-tail | did it pull member reading time?
 
+Both still carry OKF frontmatter (one block at the top of each file):
+
+```markdown
+---
+type: medium-record
+title: Publications tracker   # or: Tag sets tried
+description: Accepted / pitched / dropped Medium publications and their guideline notes.
+tags: [medium, publications]   # or [medium, tags, distribution] for tags.md
+timestamp: 2026-09-01T00:00:00Z
+topic: medium
+status: stable
+---
+```
+
 ## The verify.sh contract
 
 `scripts/verify.sh` is a **structural lint, not a craft judge.** Run it after a session:

package/skills/medium-writing/SKILL.md

@@ -117,6 +117,25 @@ If `02-DOCS/` exists, learn before you write:
 - Bias toward the title/subtitle patterns and topics that historically beat a 50% read ratio for *this* author; avoid angles that drew clicks but bounced.
 - After a notable result, append the learned pattern to `02-DOCS/wiki/medium/read-ratio-patterns.md` so the next draft inherits it.
 
+`read-ratio-patterns.md` lives in the `02-DOCS/wiki/` OKF v0.1 bundle, so it carries YAML frontmatter with a non-empty `type:` — one block at the top, with new pattern blocks prepended newest-first below it. Use `type: medium-record` (the same type the `medium-strategy` skill writes under `02-DOCS/wiki/medium/`, keeping the two skills' wiki content consistent). Create it with this header if it does not yet exist:
+
+```markdown
+---
+type: medium-record
+title: Read-ratio patterns — Medium
+description: Title/subtitle/topic patterns that historically beat a 50% read ratio for this author.
+tags: [medium, read-ratio, titles, hooks]
+timestamp: 2026-06-02T00:00:00Z
+topic: medium
+status: stable
+---
+
+## 2026-06-02 — <pattern learned>
+- <title/subtitle archetype + topic that beat the 50% read ratio, with the number observed>
+```
+
+Cross-references use standard markdown links (`[Text](./what-worked.md)`), never wikilinks (`[[...]]`).
+
 If `02-DOCS/` is absent, proceed from the craft defaults above and say so in one line, rather than inventing stats.
 
 ## Anti-patterns

package/skills/plan/references/plan-template.md

@@ -9,9 +9,20 @@ flows, levels — not framework syntax.
 ---
 
 ```markdown
+---
+type: plan
+title: Plan — <feature name>
+description: The structure-level implementation plan for <feature> — contracts, shapes, flows.
+tags: [sdd, plan]
+timestamp: YYYY-MM-DDTHH:MM:SSZ
+topic: sdd
+slug: <slug>
+status: draft
+---
+
 # Plan — <feature name>
 
-> Spec: ../specs/<slug>.md · Constitution: ../constitution.md · Status: draft | approved
+> Spec: [../specs/<slug>.md](../specs/<slug>.md) · Constitution: [../constitution.md](../constitution.md) · Status: draft | approved
 > Last updated: YYYY-MM-DD
 
 ## 0. Global Constraints

package/skills/roast-me/tools/adapters/base.py

@@ -17,10 +17,22 @@ An adapter MUST:
 
 from __future__ import annotations
 
+import re
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any
 
+#: Shared correction detector — a user message matching this right after a prompt
+#: signals the previous turn went wrong. Single source of truth for every adapter
+#: (and re-used by extract_prompts.py) so the heuristic never drifts between runtimes.
+CORRECTION_RE = re.compile(
+    r"\b(no[,.]?\s|wrong|instead|actually|don'?t|shouldn'?t|stop|not that|"
+    r"I said|I meant|I asked|that'?s not|please don'?t|why did you|"
+    r"you should have|that was wrong|incorrect|try again|redo|"
+    r"that broke|you broke|revert|undo)\b",
+    re.IGNORECASE,
+)
+
 
 class BaseAdapter(ABC):
     """Contract every runtime adapter must satisfy."""

package/skills/roast-me/tools/adapters/codex.py

@@ -1,36 +1,71 @@
 """Codex CLI adapter (@openai/codex).
 
 Session files: ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>.jsonl
-Format: JSON Lines. Each line is an event object.
-
-CONFIRMED (2026-06, via official CLI reference and community tooling):
-  - Base path: ~/.codex/sessions/
-  - Subdirectory layout: year/month/day
-  - File naming: rollout-<ISO-timestamp>.jsonl
-  - Format: JSONL, one event per line
-
-STUBBED (format details):
-  The internal schema of each JSONL line has not been verified against a live
-  Codex installation. Based on community-authored session viewers, events appear
-  to carry {"role": "user"|"assistant", "content": "...", ...}. If the role
-  field is absent or the schema differs, parse() returns [] gracefully.
-
-Degradation: if ~/.codex/ does not exist, discover() returns [].
+Format: JSON Lines. Each line is {"timestamp", "type", "payload"}.
+
+CONFIRMED (2026-06, against live ~/.codex/sessions on macOS):
+  - Base path / layout / naming: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+  - Line envelope: {"timestamp": ISO8601, "type": str, "payload": {...}}
+  - The genuine user prompt is an `event_msg` line whose payload.type is
+    "user_message", carrying the typed text in payload.message. (Injected
+    AGENTS.md / developer preambles appear only as response_item/message lines,
+    so keying on user_message excludes them.)
+  - Assistant turns: event_msg/agent_message (payload.message) and
+    response_item/message role=assistant.
+  - Tool calls: response_item/function_call (payload.name).
+  - Tool results: response_item/function_call_output (payload.output) — shell
+    execs include a "Process exited with code N" line; N != 0 (or common error
+    markers) means the command failed.
+  - Model: turn_context.model / session_meta payload.
+
+Degradation: if ~/.codex/ does not exist, discover() returns []; any unexpected
+line shape is skipped, so parse() never raises.
 """
 
 from __future__ import annotations
 
+import datetime
 import json
+import re
 from pathlib import Path
 from typing import Any
 
-from .base import BaseAdapter
+from .base import CORRECTION_RE, BaseAdapter
+
+# A shell tool result failed when it reports a non-zero exit code, or carries a
+# common error marker with no explicit success code. Conservative on purpose —
+# better to miss a soft error than to invent one.
+_EXIT_CODE_RE = re.compile(r"exited with code\s+(\d+)", re.IGNORECASE)
+_ERROR_MARKER_RE = re.compile(
+    r"\b(command not found|no such file|permission denied|traceback \(most recent|"
+    r"fatal:|panic:|segmentation fault|unhandled exception)\b",
+    re.IGNORECASE,
+)
+
+
+def _looks_like_error(output: str) -> bool:
+    if not output:
+        return False
+    m = _EXIT_CODE_RE.search(output)
+    if m:
+        return m.group(1) != "0"
+    return bool(_ERROR_MARKER_RE.search(output))
+
+
+def _ts(value: Any) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return datetime.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+        except (ValueError, AttributeError):
+            return None
+    return None
 
 
 class CodexAdapter(BaseAdapter):
     RUNTIME_ID = "codex"
 
-    # CONFIRMED: path layout from official CLI docs and community tools.
     SESSIONS_DIR = Path.home() / ".codex" / "sessions"
 
     def discover(self) -> list[Path]:
@@ -50,17 +85,17 @@ class CodexAdapter(BaseAdapter):
         return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
 
     def parse(self, path: Path) -> list[dict[str, Any]]:
-        """Parse one Codex session JSONL file.
-
-        STUBBED schema: assumes {"role": "user", "content": "..."} event lines.
-        Falls back silently if the schema differs.
-        """
-        records: list[dict[str, Any]] = []
+        """Parse one Codex session JSONL file into user-prompt records with
+        session-aware error/correction context."""
         try:
             lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
         except OSError:
             return []
 
+        # 1) Flatten the file into an ordered timeline of turns.
+        timeline: list[dict[str, Any]] = []
+        model = ""
+        pending_tool = ""
         for line in lines:
             line = line.strip()
             if not line:
@@ -69,45 +104,103 @@ class CodexAdapter(BaseAdapter):
                 obj = json.loads(line)
             except json.JSONDecodeError:
                 continue
+            if not isinstance(obj, dict):
+                continue
 
-            # STUBBED: expected schema based on community session viewers.
-            role = obj.get("role") or obj.get("type", "")
-            if role != "user":
+            top_type = obj.get("type")
+            payload = obj.get("payload")
+            if not isinstance(payload, dict):
+                payload = {}
+            ts = _ts(obj.get("timestamp"))
+
+            # Track the active model from session metadata / turn context.
+            if top_type in ("session_meta", "turn_context"):
+                m = payload.get("model")
+                if isinstance(m, str) and m:
+                    model = m
                 continue
 
-            content = obj.get("content", "")
-            if isinstance(content, list):
-                # Some formats use a content array like OpenAI chat API.
-                parts = [
-                    c.get("text", "") if isinstance(c, dict) else str(c)
-                    for c in content
-                    if isinstance(c, dict) and c.get("type") == "text"
-                ]
-                text = "\n".join(parts)
-            elif isinstance(content, str):
-                text = content
-            else:
-                text = ""
-
-            if not text.strip():
+            if top_type == "event_msg":
+                p_type = payload.get("type")
+                if p_type == "user_message":
+                    text = payload.get("message", "")
+                    if isinstance(text, str) and text.strip():
+                        timeline.append({"kind": "user", "text": text, "ts": ts})
+                elif p_type == "agent_message":
+                    text = payload.get("message", "")
+                    if isinstance(text, str) and text.strip():
+                        timeline.append({"kind": "assistant", "text": text, "ts": ts})
                 continue
 
-            ts = obj.get("timestamp") or obj.get("created_at")
-            if isinstance(ts, str):
-                try:
-                    import datetime
-                    dt = datetime.datetime.fromisoformat(ts.replace("Z", "+00:00"))
-                    ts = dt.timestamp()
-                except (ValueError, AttributeError):
-                    ts = None
-            elif not isinstance(ts, (int, float)):
-                ts = None
+            if top_type == "response_item":
+                p_type = payload.get("type")
+                if p_type == "function_call":
+                    name = payload.get("name", "")
+                    pending_tool = name if isinstance(name, str) else ""
+                elif p_type == "function_call_output":
+                    output = payload.get("output", "")
+                    output = output if isinstance(output, str) else json.dumps(output)
+                    timeline.append({
+                        "kind": "tool_output",
+                        "tool": pending_tool,
+                        "is_error": _looks_like_error(output),
+                        "text": output,
+                        "ts": ts,
+                    })
+                    pending_tool = ""
+                # response_item/message (assistant/user/developer) is intentionally
+                # ignored: genuine prompts come from event_msg/user_message, and the
+                # assistant context comes from event_msg/agent_message.
+                continue
+
+        # 2) Walk the timeline; enrich each user prompt with what follows it.
+        user_indices = [i for i, t in enumerate(timeline) if t["kind"] == "user"]
+        records: list[dict[str, Any]] = []
+        for n, idx in enumerate(user_indices):
+            turn = timeline[idx]
+            next_user = user_indices[n + 1] if n + 1 < len(user_indices) else len(timeline)
+
+            followed_by_error = False
+            error_tool = ""
+            error_text = ""
+            for j in range(idx + 1, next_user):
+                t = timeline[j]
+                if t["kind"] == "tool_output" and t.get("is_error"):
+                    followed_by_error = True
+                    error_tool = t.get("tool", "")
+                    error_text = t.get("text", "")
+                    break
+
+            followed_by_correction = False
+            correction_text = ""
+            if next_user < len(timeline):
+                nxt = timeline[next_user]["text"]
+                if CORRECTION_RE.search(nxt):
+                    followed_by_correction = True
+                    correction_text = nxt
+
+            # context_before: last assistant text strictly before this prompt.
+            context_before = ""
+            for j in range(idx - 1, -1, -1):
+                if timeline[j]["kind"] == "assistant":
+                    context_before = timeline[j]["text"]
+                    break
+
+            error_was_recovered = followed_by_error and not followed_by_correction
 
             records.append({
                 "runtime": self.RUNTIME_ID,
                 "session_file": str(path),
-                "prompt_text": text,
-                "timestamp": ts,
+                "prompt_text": turn["text"],
+                "timestamp": turn.get("ts"),
+                "model": model,
+                "context_before": context_before,
+                "followed_by_error": followed_by_error,
+                "error_was_recovered": error_was_recovered,
+                "followed_by_correction": followed_by_correction,
+                "correction_text": correction_text,
+                "error_tool": error_tool,
+                "error_text": error_text,
             })
 
         return records