@r1z4x/tezgah 1.1.0 → 1.2.0

package/docs/judge.md

@@ -28,11 +28,14 @@ A session CLI answers in 4-10 s (measured 2026-10-07), so the skill hint's
 4 s deadline usually ends first. `TEZGAH_TYPESAFE_URL`, `TEZGAH_OPENROUTER_URL`
 and `TEZGAH_OMP_BIN`/`TEZGAH_CLAUDE_BIN` are the test seams.
 
-Every caller reads an answer through the same two accessors rather than reaching
+Every caller reads an answer through the same accessors rather than reaching
 into the raw reply, so a Choice and a Noul are read one way for all five
 (`choice`, `hooks/tezgah_judge.py::choice`; `noul`,
-`hooks/tezgah_judge.py::noul`). Both are total: a missing or wrongly-typed
-answer is a `None`, never an exception.
+`hooks/tezgah_judge.py::noul`). A `text` question is the one shape that asks
+for prose. `bin/tezgah-taste` asks it for a learning's readable line, and only
+a generative provider answers one. TypeSafe is never sent one (`text`,
+`hooks/tezgah_judge.py::text`). All three are total: a missing or
+wrongly-typed answer is a `None`, never an exception.
 
 A judgement is an aid, never the claim. It ranks units or names a page; the agent
 still reads the selected refs and owns the finding, and the ledger's step kinds
@@ -69,7 +72,7 @@ why its redaction is not optional. The switches below are the off buttons.
 | `bin/tezgah-docs` | the docs page fallback: only when the keyword index placed nothing, one Choice over the pages with `none` offered (`judge_pick`, `bin/tezgah-docs::judge_pick`; the question wording is `ASK`, `bin/tezgah-docs::ASK`) | reads as no judgement; with none (no credential, `judge-off`, `docs-judge-off`, or a call that failed or came back without one of its options) the pages are ranked by shared words instead (`ranked`, BM25 in `hooks/tezgah_rank.py` over each page's title and answers and their Turkish phrasings) and the top three printed; a query sharing no word with any page, or a judged `none`, exits 1. With the opt-in embedding feature on, the ranking is fused with a static embedding (`hooks/tezgah_embed.py`), which places every page, so only a judged `none` exits 1 |
 | `hooks/tezgah_skill_pick.py` | the prompt-path skill hint: a Choice over the roster skills plus one Noul (`judge`, `hooks/tezgah_skill_pick.py::judge`, with the criteria cut from each skill's own clauses, `clause`, `hooks/tezgah_skill_pick.py::clause`), behind a threshold (`GATE`, `hooks/tezgah_skill_pick.py::GATE`), one attempt and a 4 s wall-clock deadline (`ASK_DEADLINE`, `hooks/tezgah_skill_pick.py::ASK_DEADLINE`), the prompt redacted and cut at 2,000 characters | returns `""`; the turn loses the hint |
 | `bin/tezgah-route` | the tier router: after the deterministic overrides, one Choice over the three tiers for a delegation brief (`route`, `hooks/tezgah_models.py::route`; `TIER_QUESTION`, `hooks/tezgah_models.py::TIER_QUESTION`) - see [models](models.md) | the static phase table, else the middle tier |
-| `bin/tezgah-taste` | the coding-taste measurement: `measure` and `rate` label the prompts a user sent after a writing turn, one Choice per prompt batched into one request, each prompt redacted first (`classify`, `bin/tezgah-taste::classify`) | with no credential or `judge-off` it exits 2 before any request; a failed call leaves its prompts unlabelled |
+| `bin/tezgah-taste` | the coding-taste measurement and learning: `measure` and `rate` label the prompts a user sent after a writing turn, one Choice per prompt batched into one request, each prompt redacted first (`classify`, `bin/tezgah-taste::classify`). `learn` asks one typed decision per signal and requires TypeSafe (`decide`, `bin/tezgah-taste::decide`). For a learning that turns active it asks one `text` question of a generative provider (`write_line`, `bin/tezgah-taste::write_line`) | with no credential or `judge-off` it exits 2 before any request. A failed call leaves its prompts unlabelled. A decision another provider gave is recorded `unverified` and never applied. A missing line keeps the user's own words |
 
 The third caller is the one no shell row can see: it runs on the prompt path,
 caches one answer per `(session, prompt)` (`_remember`,
@@ -114,6 +117,12 @@ not. That answer, and a refusal with its failures, is said on stderr as one
 `hooks/tezgah_judge.py::_record`), which `tezgah-status --judge` prints. The skill
 hint's cost row and the router's `route` row also carry `judge=<provider>/<model>`.
 
+A caller that needs one provider in particular passes `only` (`named`,
+`hooks/tezgah_judge.py::named`). `learn`'s decision has to come from a typed
+model, so it passes `only=("typesafe",)`. It gets `None` rather than another
+provider's answer. The caller named the provider, so the `vendor` order does not
+apply. `none` still keeps every third party out.
+
 ## The switches
 
 `judge-off` is the master: with it armed `available()` is false and no caller

package/docs/operations.md

@@ -385,15 +385,18 @@ extension the engine has no parser for and an extensionless script it cannot key
 on at all. The extensionless case is why `bin/*` carries `.py` twins, and the
 report counts a tracked `bin/x` as covered when the index holds `bin/x.py`.
 
-## Opt-in taste capture
-
-Phase 1 of a coding-taste learner stores the signals tezgah already receives.
-It learns nothing and injects nothing yet. It stays off until the user arms it
-with a `taste-on` file in `~/.config/tezgah/` (`enabled`,
-`hooks/tezgah_taste.py::enabled`). The off path costs two stats. Armed, it writes
-only into a repository that already has a `.tezgah/` directory. A `.no-taste`
-mark turns it off for one repository (`hooks/tezgah_context.py::repo_marks`).
-A workspace of repo-provided data gets nothing.
+## Opt-in taste: capture, learn, apply
+
+Taste learns the user's coding preferences from their own corrections. It is
+taste-1's architecture as Command Code documents it, ported to tezgah (research
+line taste-architecture, design T1P). An LLM-free structured signal goes to a
+typed decision step, then a symbolic ledger, then a meta loop. It stays off
+until the user arms it with a `taste-on` file in `~/.config/tezgah/` (`enabled`,
+`hooks/tezgah_taste.py::enabled`). The off path costs two stats. Armed, it
+writes only into a repository that already has a `.tezgah/` directory. A
+`.no-taste` mark turns it off for one repository
+(`hooks/tezgah_context.py::repo_marks`). A workspace of repo-provided data gets
+nothing.
 
 Rows go to `<repo>/.tezgah/taste/signals.jsonl` through the ledger's own writer
 (`_write`, `hooks/tezgah_taste.py::_write`). A user turn adds a `prompt` row,
@@ -409,22 +412,69 @@ ledger row. A rollback therefore never reads it as a pre-state (`capture_after`,
 `hooks/tezgah_snapshot.py::capture_after`). A file outside the repository gets no
 after blob.
 opencode reaches the same call through a process (`noteTaste`,
-`hosts/opencode/plugins/tezgah.js:2310-2319`).
+`hosts/opencode/plugins/tezgah.js:2380-2390`).
 
 ```sh
 touch ~/.config/tezgah/taste-on               # arm; rm it to disarm
+bin/tezgah-taste learn                        # decide the new capture signals, update the ledger
+bin/tezgah-taste learn --from-transcripts     # bootstrap from this repo's omp/Claude history
+bin/tezgah-taste list                         # learnings: state, rule/hint, confidence, scope
+bin/tezgah-taste accept|reject|show ID        # the user's call on one learning
+bin/tezgah-taste edit ID --text "..."         # reword it; an edited line is never rewritten
+bin/tezgah-taste export                       # accepted learnings into AGENTS.md
+bin/tezgah-taste label; bin/tezgah-taste label ID preference   # the calibration sample
+bin/tezgah-taste calibrate                    # the bound a rule needs
+bin/tezgah-taste gate                         # the pooled before/after test
 bin/tezgah-taste mine --host omp --stats      # sessions, writes, prompts after a writing turn
-bin/tezgah-taste mine --out mined.jsonl       # one row per such prompt, redacted
-bin/tezgah-taste measure --samples S --labels L   # judge precision/recall against labels
-bin/tezgah-taste rate --in mined.jsonl        # preference corrections per writing turn
+bin/tezgah-taste measure --samples S --labels L [--typed]   # judge precision/recall
 ```
 
-`mine` reads the host transcripts already on disk, so it needs no capture. It
-reads omp's top-level session files and Claude's top-level transcripts whose cwd
-is under `--root` (`cmd_mine`, `bin/tezgah-taste::cmd_mine`). `measure` and `rate`
-send the sample text to the judge seam's provider ([judge](judge.md)), redacted
-first (`classify`, `bin/tezgah-taste::classify`). They use a fixed labelling rule
-(`RULE`, `bin/tezgah-taste::RULE`). Without a credential they send nothing.
+`learn` turns each prompt that followed a writing turn into one signal, and code
+builds it (`capture_signals`, `bin/tezgah-taste::capture_signals`). A signal
+holds the prompt, the files written, the agent's edits, and the user's own edit
+between two agent writes. That last one compares the after blob with the next
+write's pre-state, or with the file on disk (`user_diff`,
+`bin/tezgah-taste::user_diff`). `learn` asks TypeSafe for one typed decision per
+signal (`decide`, `bin/tezgah-taste::decide`, [judge](judge.md)). The decision
+names preference, defect or none. It picks one of eleven fixed categories and a
+scope. It also says how the signal relates to each learning held: supports,
+contradicts, narrows or unrelated. When another provider answers, `learn` writes
+the decision to `decisions.jsonl` as `unverified` and never applies it. A defect
+goes to `defects.jsonl` and never into the ledger.
+
+The ledger is `<repo>/.tezgah/taste/ledger.json`, plus
+`~/.config/tezgah/taste/ledger.json` for user-scope learnings
+(`hooks/tezgah_taste_ledger.py`). Confidence is (r+1)/(r+s+2) over supporting
+and contradicting evidence. Each piece counts at its decision probability, and
+the ledger forgets it per day at its scope's rate (`confidence`,
+`hooks/tezgah_taste_ledger.py::confidence`). A learning turns active in its
+second session. A contradiction flags an active learning `conflicted` and stores
+the contrary claim `quarantined`. Neither overwrites the other. `narrows` adds a
+narrower learning beside the broader one. When the user corrects an injected
+learning's category in the same session, that learning loses confidence
+(`apply`, `hooks/tezgah_taste_ledger.py::apply`). The hooks only read the
+ledgers. `learn`, `accept`, `reject` and `edit` rewrite them one at a time on
+this machine, under a lock on `~/.config/tezgah/taste/ledger.lock` (`locked`,
+`hooks/tezgah_taste_ledger.py::locked`). The lock spans every repository,
+because each command also rewrites the user ledger. A second one exits 2 and
+names the holder. Every taste row goes through the evidence ledger's locked
+writer (`append`, `hooks/tezgah_taste_ledger.py::append`).
+
+Session start injects the active learnings (`block`,
+`hooks/tezgah_taste_ledger.py::block`). A rule needs confidence 0.8 and a
+Clopper-Pearson lower bound of 0.8 on preference precision, measured on the
+labelled sample (`calibration`, `hooks/tezgah_taste_ledger.py::calibration`). A
+hint needs 0.6. A learning whose evidence paths are all gone is withheld. A
+write also carries the in-scope learnings it has not yet shown in the session,
+on every host's post-tool channel (`write_note`, `hooks/tezgah_taste.py::write_note`).
+`gate` compares preference corrections per writing turn before and after the
+first injection, by when each turn happened. Once both arms hold 980 turns and
+the after-rate is not lower
+at one-sided p < 0.1, it writes `gate.json` and injection stops (`gate`,
+`hooks/tezgah_taste_ledger.py::gate`). `mine` reads omp's top-level session
+files and Claude's top-level transcripts whose cwd is under `--root`
+(`cmd_mine`, `bin/tezgah-taste::cmd_mine`). `measure` and `rate` use a fixed
+labelling rule (`RULE`, `bin/tezgah-taste::RULE`).
 
 ## Tidying the lessons ledger
 
@@ -580,8 +630,8 @@ question instead of paying an agent to read a page: the analyze-app loop's snaps
 triage (`bin/tezgah-triage`), `bin/tezgah-docs` for a query its keyword index
 cannot place, and the prompt-path skill hint (`hooks/tezgah_skill_pick.py`), the
 one caller no shell row sees, `bin/tezgah-route`, the tier router
-([models](models.md)), and `bin/tezgah-taste`'s `measure` and `rate`
-([above](#opt-in-taste-capture)). All five go through the same stdlib-only seam,
+([models](models.md)), and `bin/tezgah-taste`'s `measure`, `rate` and `learn`
+([above](#opt-in-taste-capture-learn-apply)). All five go through the same stdlib-only seam,
 which returns `None` rather than raising because a hook may import it
 (`available()`, `hooks/tezgah_judge.py::available`); the request is
 one batched call, and the credential resolves per call (`ask()`,

package/hooks/projects-posttooluse.py

@@ -26,6 +26,7 @@ try:
     from tezgah_integrity import (  # noqa: E402
         SUBAGENT_CHANNEL, note_tool, ran_nothing, report_bytes, untrusted_source)
     from tezgah_paths import root_for  # noqa: E402
+    from tezgah_taste import write_note  # noqa: E402
     from tezgah_untrusted import marks  # noqa: E402
 except Exception as exc:
     import_failed(exc)
@@ -139,6 +140,12 @@ def main():
          # empty-run contract (tezgah_integrity.EMPTY_RUN)
          empty_run=ran_nothing(result),
          agent=agent)
+    # the opt-in taste note: the learnings in scope for the first write to this
+    # file type in the session (hooks/tezgah_taste.write_note), beside the
+    # provenance line rather than instead of it
+    if event == "PostToolUse" and not failed:
+        notice = "\n".join(t for t in (notice, safe(session_id, write_note, session_id,
+                                                     inp, cwd, tool)) if t)
     if notice:
         json.dump({"hookSpecificOutput": {
             "hookEventName": event,

package/hooks/tezgah_context.py

@@ -1412,7 +1412,7 @@ DEFAULT_BUDGET = 13000
 # spend them would turn bloat into rule loss - which is the failure the budget
 # exists to prevent, not one it may cause.
 DROP_ORDER = ("knowledge", "worktrees", "lessons", "skill", "lessons_turn",
-              "plans", "subagents", "steer", "orca", "consult", "research",
+              "taste", "plans", "subagents", "steer", "orca", "consult", "research",
               "research_broken", "graph", "offnote", "orchestrate", "index",
               "resume", "scratch", "task", "delta", "pointer")
 
@@ -2087,6 +2087,7 @@ def context_for(event, cwd, payload=None, with_core=True):
              else [("core", core)]) if with_core else []
     _, marks = repo_marks(cwd)
     injected = []  # the session block's lessons, when it carries them
+    taste = ""  # the session block's taste learnings, when it carries them
     if ".no-graph" in marks:
         parts.append(("graph", "Graph: disabled for this repo (.no-graph), so use "
                                "grep/find and say the answer came from text "
@@ -2188,6 +2189,19 @@ def context_for(event, cwd, payload=None, with_core=True):
                     recent = lesson_lines(root)[-LESSON_LINES:]
                     injected = list(zip(recent, _lesson_shown(
                         recent, tainted_lessons(root))))
+        # The opt-in taste learnings (hooks/tezgah_taste_ledger.block): the
+        # active ones as rules or hints, read from the ledger with no call out;
+        # off, `enabled` costs the marker stat. The injection is recorded below,
+        # only when the budget kept the block.
+        taste_root = tezgah_taste.enabled(cwd) if tezgah_taste else None
+        if taste_root:
+            try:
+                import tezgah_taste_ledger
+                taste, taste_ids = tezgah_taste_ledger.block(taste_root)
+            except Exception:
+                taste = ""
+            if taste:
+                parts.append(("taste", taste))
         broken = tezgah_research.failing(root) if not off("research-off") else []
         if broken:
             line_slug, err = broken[0]
@@ -2219,6 +2233,11 @@ def context_for(event, cwd, payload=None, with_core=True):
     for ln, line in injected:
         if "\n- " + line + "\n" in text:
             note_lesson(session_of(payload), lesson_key(ln), "session")
+    if taste and taste.split("\n", 1)[0] in text:
+        try:
+            tezgah_taste_ledger.record_injection(taste_root, session_of(payload), taste_ids)
+        except Exception:
+            pass
     return text
 
 

package/hooks/tezgah_judge.py

@@ -68,9 +68,10 @@ FALLBACK_MODEL = "deepseek/deepseek-v4-flash"
 # The contract the fallback asks a chat model to answer in, one shape per
 # question type this repository's callers send (`bin/tezgah-triage` and
 # `hooks/tezgah_skill_pick.py` ask `noul`, `bin/tezgah-docs` and the triage's
-# pair rows ask `choice`). It is prose because a chat endpoint has no schema
-# field to carry it; every field it names is validated on the way back, and a
-# question of any other type reads as unanswered rather than as a guess.
+# pair rows ask `choice`, `bin/tezgah-taste` asks `text` for a learning's
+# readable line). It is prose because a chat endpoint has no schema field to
+# carry it; every field it names is validated on the way back, and a question
+# of any other type reads as unanswered rather than as a guess.
 CHAT_SYSTEM = (
     "You answer questions about the state that follows. Reply with one JSON "
     "object and nothing else: {\"answers\": {\"<id>\": {...}}}, one entry per "
@@ -78,6 +79,7 @@ CHAT_SYSTEM = (
     "noul   -> {\"noul\": <probability 0..1 that the statement is true>}\n"
     "choice -> {\"choice\": \"<the chosen label>\", \"probabilities\": "
     "{\"<label>\": <probability>, ...}, \"confidence\": <0..1>}\n"
+    "text   -> {\"text\": \"<the answer as plain prose>\"}\n"
     "Every probability is a number in 0..1 and the ones you list for one "
     "question sum to 1. Answer every id you were given.")
 
@@ -188,6 +190,20 @@ def providers():
                   (("typesafe", key()), ("openrouter", openrouter_key())) if secret]
 
 
+def named(only):
+    """`providers()` for a caller that requires particular ones: every provider
+    in `only` that resolves, in `only`'s order. The `vendor` policy's
+    session-first order does not apply - the caller named the provider, so
+    nothing is a silent fallback - but `none` still keeps every third party
+    out."""
+    session = tp.session_cli()
+    third = tp.fallback_policy() != "none"
+    found = {session: getattr(tp, session + "_bin")()} if session else {}
+    if third:
+        found.update(typesafe=key(), openrouter=openrouter_key())
+    return [(name, found[name]) for name in only if found.get(name)]
+
+
 def credential():
     """`(provider, secret)` for the first provider `ask()` will try, else
     `(None, None)` - so `available()` and `ask()` cannot disagree."""
@@ -200,7 +216,8 @@ def available():
     return bool(credential()[1]) and not tp.off("judge-off")
 
 
-def ask(state, questions, *, model=MODEL, timeout=30, attempts=2, deadline=None):
+def ask(state, questions, *, model=MODEL, timeout=30, attempts=2, deadline=None,
+        only=None):
     """One batched call over `questions`; `{"answers", "usage", "latency_ms",
     "model", "provider", "fallback"}`.
 
@@ -233,18 +250,29 @@ def ask(state, questions, *, model=MODEL, timeout=30, attempts=2, deadline=None)
 
     Total by design: no provider, an unreadable state, a refused request, a
     timeout, a reply that is not the documented shape - all `None`, never an
-    exception."""
-    if not credential()[1]:
+    exception.
+
+    `only` names the providers the caller requires (`named()`); a caller whose
+    decision must come from a typed model passes `only=("typesafe",)` and gets
+    None rather than another provider's answer."""
+    tried = providers() if only is None else named(only)
+    if any(isinstance(q, dict) and q.get("type") == "text" for q in questions.values()):
+        # TypeSafe answers no prose: left out up front, not logged as a failure
+        tried = [(p, s) for p, s in tried if p != "typesafe"]
+    if not tried or not tried[0][1]:
         return None
     stop = None if deadline is None else time.monotonic() + deadline
     failed = []
-    for provider, secret in providers():
+    for provider, secret in tried:
         result, why = _ask_one(provider, secret, state, questions, model,
                                timeout, attempts, stop)
         if result is None:
             failed.append("%s: %s" % (provider, why))
             continue
-        note = "; ".join(failed) or (None if provider in SESSION_ARGV else NO_SESSION)
+        # a provider the caller named is not a stand-in: no note, unless an
+        # earlier one it named failed
+        note = "; ".join(failed) or (None if only is not None or provider in SESSION_ARGV
+                                     else NO_SESSION)
         result["fallback"] = note
         _record(result["provider"], result["model"], fallback=note)
         return result
@@ -328,6 +356,14 @@ def choice(result, id):
     return value if isinstance(value, str) else None
 
 
+def text(result, id):
+    """The prose a `text` question came back with, stripped, or None. Only a
+    generative provider answers one; TypeSafe is never sent one."""
+    answer = _answer(result, id)
+    value = answer.get("text") if answer else None
+    return (value.strip() or None) if isinstance(value, str) else None
+
+
 def noul(result, id, option=None):
     """The probability a Noul question came back with, or None.
 
@@ -448,17 +484,20 @@ def _chat_answers(parsed, questions):
 def _clean_answer(raw, kind):
     """One answer in the shape its question type names, or None.
 
-    The two shapes this repository's callers send - `noul`, the probability a
-    statement holds, and `choice`, the label taken - map onto exactly what
-    `choice()`/`noul()` already read, so a fallback answer and a TypeSafe answer
-    are indistinguishable downstream. Any other type reads as no answer rather
-    than as a guess. Probabilities are kept only when they are numbers, because
-    `noul()` does the arithmetic on them."""
+    The shapes this repository's callers send - `noul`, the probability a
+    statement holds, `choice`, the label taken, and `text`, prose - map onto
+    exactly what `choice()`/`noul()`/`text()` already read, so a fallback answer
+    and a TypeSafe answer are indistinguishable downstream. Any other type reads
+    as no answer rather than as a guess. Probabilities are kept only when they
+    are numbers, because `noul()` does the arithmetic on them."""
     if not isinstance(raw, dict):
         return None
     if kind == "noul":
         value = raw.get("noul")
         return {"noul": float(value)} if isinstance(value, (int, float)) else None
+    if kind == "text":
+        value = raw.get("text")
+        return {"text": value} if isinstance(value, str) and value.strip() else None
     if kind != "choice":
         return None
     if not isinstance(raw.get("choice"), str):

package/hooks/tezgah_taste.py

@@ -9,11 +9,12 @@ workspace that came with the clone is data, and nothing of the user's is
 written into it). The store is `<git root>/.tezgah/taste/signals.jsonl`, one
 JSON object per line, owner-only.
 
-Every public function is total: it never raises, makes no network call and
-appends at most one row. They run on the prompt and PostToolUse hot paths, so
-the switch is read before anything else is.
+Every public function is total: it never raises and makes no network call.
+The capture functions append at most one row each. They run on the prompt and
+PostToolUse hot paths, so the switch is read before anything else is.
 
-Nothing here is learned or fed back into a prompt; this is capture only.
+Learning lives in `bin/tezgah-taste learn` and `tezgah_taste_ledger`; the one
+thing fed back from here is `write_note`, the learnings in scope for a write.
 """
 import datetime
 import json
@@ -181,16 +182,41 @@ def note_write(session_id, row_id, inp, cwd, host=None):
         pass
 
 
+def write_note(session_id, inp, cwd, tool=None):
+    """The in-scope taste learnings this write has not yet shown in the session
+    (`tezgah_taste_ledger.write_note`), or "". Every host's post-tool
+    channel carries it beside its other notices; off, it costs the marker stat.
+    `tool` is the call's tool name; a call that is not a write gets nothing."""
+    try:
+        if not armed(ARM) or not isinstance(inp, dict) or inp.get("command") == "view" \
+                or (tool is not None and str(tool).lower() not in ti.WRITE_TOOLS):
+            return ""
+        from tezgah_gate import write_paths
+        paths = write_paths(inp)
+        root = enabled(cwd)
+        rel = _rel(root, paths[0], cwd) if root and paths else None
+        if rel is None:
+            return ""
+        import tezgah_taste_ledger
+        return tezgah_taste_ledger.write_note(root, session_id, rel)
+    except Exception:
+        return ""
+
+
 def main(argv):
-    """`tezgah_taste.py '<json>'`: `note_write` for a host that cannot call it
-    in process (opencode's plugin is JavaScript). The one argument is
-    {"session_id", "id", "input", "cwd", "host"}. Silent, exit 0 always."""
+    """`tezgah_taste.py '<json>'`: `note_write`, then `write_note`, for a host
+    that cannot call them in process (opencode's plugin is JavaScript). The one
+    argument is {"session_id", "id", "input", "cwd", "host"}. Prints the note
+    (nothing when there is none); exit 0 always."""
     try:
         payload = json.loads(argv[0]) if argv else {}
         if isinstance(payload, dict):
+            cwd = payload.get("cwd") or os.getcwd()
             note_write(payload.get("session_id"), payload.get("id"),
-                       payload.get("input"), payload.get("cwd") or os.getcwd(),
-                       payload.get("host"))
+                       payload.get("input"), cwd, payload.get("host"))
+            note = write_note(payload.get("session_id"), payload.get("input"), cwd)
+            if note:
+                print(note)
     except Exception:
         pass
     return 0