Skip to content
Sign up

flagon-io/g1t

public
00

Where people and agents ship software together. The open-source git platform for the whole job: issues, agents, checks and deploys to the edge.

gitagentscloudflarerustforgemcp
977 linesCodeBlameRaw
1// Tests for the plugin's hooks: node --test plugins/claude-code/test/
2import assert from "node:assert/strict";
3import { spawnSync } from "node:child_process";
4import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
5import { tmpdir } from "node:os";
6import { join } from "node:path";
7import { afterEach, beforeEach, describe, test } from "node:test";
8import { fileURLToPath } from "node:url";
9
10import {
11 retitleNudge,
12 updateContext,
13 UPDATES_REPEAT_MS,
14 howToUpdate,
15 PROMPT_LIMIT,
16 RESULT_LIMIT,
17 agentResult,
18 branchFromCommand,
19 g1tTool,
20 hasTitle,
21 hook,
22 intentTitle,
23 repoPath,
24 MIN_CLI,
25 TITLE_LIMIT,
26 oldNode,
27 older,
28 typedSkill,
29 isG1tRemote,
30 isGitCommit,
31 isGitPush,
32 issueFromBranch,
33 issueFromCommand,
34 mayAddRemote,
35 pairSubagent,
36 plan,
37 rememberTask,
38 takeTask,
39 redact,
40 sessionFiles,
41 subagentHarnessId,
42 summarizeTool,
43 work,
44} from "../hooks/g1t.mjs";
45
46import { CONTRACT, refusal } from "./fake-g1t.mjs";
47
48const HERE = fileURLToPath(new URL(".", import.meta.url));
49const SCRIPT = join(HERE, "..", "hooks", "g1t.mjs");
50const FAKE = join(HERE, "fake-g1t.mjs");
51
52const base = { session_id: "abc-123", cwd: "/work/repo", transcript_path: "/t.jsonl", permission_mode: "default" };
53
54describe("plan", () => {
55 test("SessionStart starts the session", () => {
56 const job = plan({ ...base, hook_event_name: "SessionStart", source: "startup" }, {});
57 assert.equal(job.start, true);
58 assert.deepEqual(job.steps, []);
59 });
60
61 test("UserPromptSubmit logs the prompt, cut to the limit", () => {
62 const prompt = "x".repeat(PROMPT_LIMIT + 500);
63 const job = plan({ ...base, hook_event_name: "UserPromptSubmit", prompt }, {});
64 const args = job.steps[0].args;
65 assert.deepEqual(args.slice(0, 5), ["session", "log", "--kind", "prompt", "--"]);
66 assert.equal(args[5].length, PROMPT_LIMIT);
67 assert.ok(args[5].endsWith("…"));
68 });
69
70 test("a turn Claude Code starts itself for a background task is not a prompt", () => {
71 const notification = "<task-notification>\n<task-id>a1</task-id>\n<result>SECRET OUTPUT</result>\n</task-notification>";
72 assert.equal(plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: notification }, {}), null);
73 assert.equal(plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: "hi" }, {}).steps[0].args.at(-1), "hi");
74 });
75
76 test("a prompt's intent is its first line or sentence, plain, clipped on a word", () => {
77 assert.equal(intentTitle("fix the login redirect"), "Fix the login redirect");
78 assert.equal(intentTitle("Make preview builds faster. They time out on big repositories."), "Make preview builds faster");
79 assert.equal(intentTitle("Why does `src/app.ts` fail? It worked yesterday."), "Why does src/app.ts fail?");
80 assert.equal(intentTitle("```js\nconst a = 1;\n```\n## Clean **this** up\nmore"), "Clean this up");
81 assert.equal(intentTitle("\n\n- look at [the docs](https://docs.g1t.sh) for g1t.mjs"), "Look at the docs for g1t.mjs");
82 assert.equal(intentTitle(" spread over\tspaces "), "Spread over spaces");
83 const long = intentTitle("[TEST] Tidy up the README and then look at the CI pipeline, which keeps failing on the Windows runners");
84 assert.ok(long.length <= TITLE_LIMIT, long);
85 assert.ok(long.endsWith("…") && !long.endsWith(" …"), long);
86 assert.ok(long.startsWith("[TEST] Tidy up the README"), long);
87 assert.ok("[TEST] Tidy up the README and then look at the CI pipeline, which keeps failing on the Windows runners".startsWith(long.slice(0, -1)));
88 // What was pasted or attached is left out: the words typed around it title the session.
89 assert.equal(intentTitle('<pasted_content id="5c50">\nUncaught TypeError: x is undefined\n</pasted_content>\nAlso you broke the buttons'), "Also you broke the buttons");
90 assert.equal(intentTitle("[Image #1] the PR link is missing on Home"), "The PR link is missing on Home");
91 assert.equal(intentTitle("[Image: source: C:\\tmp\\1.png]\nmake it render"), "Make it render");
92 assert.equal(intentTitle('<pasted_content id="1">only a paste'), null);
93 // What VS Code puts ahead of what was typed is not a turn Claude Code started.
94 assert.equal(
95 intentTitle("<ide_opened_file>The user opened the file c:\\a\\Dockerfile in the IDE.</ide_opened_file>\nWhether it's the desktop app or the page, it crashes"),
96 "Whether it's the desktop app or the page, it crashes",
97 );
98 assert.equal(intentTitle("<ide_selection>const a = 1;</ide_selection>\n<ide_opened_file>a.ts</ide_opened_file>\nrename this"), "Rename this");
99 assert.equal(intentTitle("<ide_opened_file>a.ts</ide_opened_file>\n/clear"), null);
100 // Not intents: slash commands, turns Claude Code starts, nothing to say.
101 for (const prompt of ["/clear", "/compact keep the plan", "/g1t:status 4", "<command-name>/clear</command-name>", '<local-command-stdout lang="en">ok</local-command-stdout>', "```\ncode only\n```", "?", "", null]) {
102 assert.equal(intentTitle(prompt), null, String(prompt));
103 }
104 });
105
106 test("UserPromptSubmit titles the session with its intent, unless prompts are kept back", () => {
107 const job = plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: "fix the login redirect" }, {});
108 assert.deepEqual(job.steps.at(-1), { title: "Fix the login redirect" });
109 assert.ok(!plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: "/clear" }, {}).steps.some((s) => s.title));
110 assert.equal(plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: "fix it" }, { G1T_RECORD_PROMPTS: "0" }), null);
111 assert.equal(hasTitle(JSON.stringify({ id: "ses_1", title: null })), false);
112 assert.equal(hasTitle(JSON.stringify({ id: "ses_1", title: " " })), false);
113 assert.equal(hasTitle(JSON.stringify({ id: "ses_1", title: "Fix it" })), true);
114 assert.equal(hasTitle("not json"), true, "unreadable: nothing is replaced");
115 });
116
117 test("G1T_RECORD_PROMPTS=0 keeps prompts back, and G1T_RECORD=0 everything", () => {
118 assert.equal(plan({ ...base, hook_event_name: "UserPromptSubmit", prompt: "hi" }, { G1T_RECORD_PROMPTS: "0" }), null);
119 assert.ok(plan({ ...base, hook_event_name: "Stop" }, { G1T_RECORD_PROMPTS: "0" }));
120 for (const hook_event_name of ["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "SessionEnd"]) {
121 assert.equal(plan({ ...base, hook_event_name, prompt: "hi", tool_name: "Bash" }, { G1T_RECORD: "0" }), null);
122 }
123 });
124
125 test("PostToolUse sends the tool and its input's summary, never its response", () => {
126 const event = {
127 ...base,
128 hook_event_name: "PostToolUse",
129 tool_name: "Bash",
130 tool_input: { command: "npm test", description: "Run the tests" },
131 tool_response: { stdout: "SECRET OUTPUT 1234", stderr: "", interrupted: false },
132 tool_use_id: "toolu_1",
133 };
134 const job = plan(event, {});
135 assert.deepEqual(job.steps, [{ args: ["session", "log", "--kind", "tool_call", "--", "Bash: npm test"] }]);
136 assert.ok(!JSON.stringify(job).includes("SECRET OUTPUT"));
137 });
138
139 test("PostToolUse after a git push updates the head commit", () => {
140 const job = plan({ ...base, hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command: "git push -u origin 42-fix" } }, {});
141 assert.deepEqual(job.steps[1], { headCommit: true });
142 const other = plan({ ...base, hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command: "git status" } }, {});
143 assert.equal(other.steps.length, 1);
144 });
145
146 test("PostToolUse remembers the issue a command claims", () => {
147 const job = plan({ ...base, hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command: "g1t work claim 42 --note x" } }, {});
148 assert.equal(job.issue, 42);
149 });
150
151 test("Stop sends a heartbeat and SessionEnd ends the session with its reason", () => {
152 assert.deepEqual(plan({ ...base, hook_event_name: "Stop", stop_hook_active: false }, {}).steps, [{ args: ["session", "heartbeat"] }]);
153 const end = plan({ ...base, hook_event_name: "SessionEnd", reason: "prompt_input_exit" }, {});
154 assert.deepEqual(end.steps, [{ args: ["session", "end", "--reason", "prompt_input_exit"] }]);
155 assert.equal(end.end, true);
156 });
157
158 test("events without a session, and other events, do nothing", () => {
159 assert.equal(plan({ hook_event_name: "Stop" }, {}), null);
160 assert.equal(plan({ ...base, hook_event_name: "PreToolUse", tool_name: "Bash" }, {}), null);
161 });
162});
163
164// Payloads as Claude Code sends them (code.claude.com/docs/en/hooks).
165const fixtures = {
166 subagentStart: {
167 session_id: "abc-123",
168 transcript_path: "/t.jsonl",
169 cwd: "/work/repo",
170 hook_event_name: "SubagentStart",
171 agent_id: "agent-def456",
172 agent_type: "Explore",
173 },
174 subagentStop: {
175 session_id: "abc-123",
176 transcript_path: "/t.jsonl",
177 cwd: "/work/repo",
178 permission_mode: "default",
179 hook_event_name: "SubagentStop",
180 stop_hook_active: false,
181 agent_id: "def456",
182 agent_type: "Explore",
183 agent_transcript_path: "/t/abc-123/subagents/agent-def456.jsonl",
184 last_assistant_message: "Analysis complete. Found 3 potential issues...",
185 background_tasks: [],
186 session_crons: [],
187 },
188 agentCompleted: {
189 ...base,
190 hook_event_name: "PostToolUse",
191 tool_name: "Agent",
192 tool_input: { description: "Find API endpoints", prompt: "Find all API endpoints", subagent_type: "Explore" },
193 tool_response: {
194 status: "completed",
195 agentId: "a4d2c8f1e0b3a297",
196 content: [{ type: "text", text: "Found 12 endpoints in src/api." }],
197 resolvedModel: "claude-sonnet-4-5",
198 totalTokens: 12450,
199 totalDurationMs: 48211,
200 totalToolUseCount: 7,
201 usage: { input_tokens: 8320, output_tokens: 410 },
202 },
203 tool_use_id: "toolu_9",
204 },
205 agentLaunched: {
206 ...base,
207 hook_event_name: "PostToolUse",
208 tool_name: "Agent",
209 tool_input: { description: "Review the diff", prompt: "Review it", subagent_type: "code-reviewer", run_in_background: true },
210 tool_response: { status: "async_launched", agentId: "b5", description: "Review the diff", prompt: "Review it", outputFile: "/tmp/b5.out", resolvedModel: "claude-sonnet-4-5" },
211 },
212 inSubagent: {
213 ...base,
214 hook_event_name: "PostToolUse",
215 agent_id: "agent-def456",
216 agent_type: "Explore",
217 tool_name: "Edit",
218 tool_input: { file_path: "/work/repo/src/api/routes.ts", old_string: "a", new_string: "b" },
219 tool_response: { filePath: "/work/repo/src/api/routes.ts", structuredPatch: "SECRET PATCH" },
220 },
221 skill: { ...base, hook_event_name: "PostToolUse", tool_name: "Skill", tool_input: { skill: "work-on-issue", args: "42" }, tool_response: { success: true, commandName: "work-on-issue" } },
222};
223
224describe("subagents", () => {
225 test("SubagentStart starts a session of its own for the subagent", () => {
226 const job = plan(fixtures.subagentStart, {});
227 assert.deepEqual(job.agent, { id: "agent-def456", type: "Explore", start: true });
228 assert.deepEqual(job.steps, []);
229 assert.equal(subagentHarnessId("abc-123", "agent-def456"), "abc-123/agent/def456");
230 assert.equal(subagentHarnessId("abc-123", "def456"), "abc-123/agent/def456", "the Agent tool's id names the same subagent");
231 });
232
233 test("SubagentStop ends it with its final message, cut to the limit", () => {
234 const job = plan(fixtures.subagentStop, {});
235 assert.deepEqual(job.agent, { id: "def456", type: "Explore" });
236 assert.deepEqual(job.steps, [{ args: ["session", "end", "--reason", "done", "--result=Analysis complete. Found 3 potential issues..."] }]);
237 const long = plan({ ...fixtures.subagentStop, last_assistant_message: "z".repeat(RESULT_LIMIT * 2) }, {});
238 assert.equal(long.steps[0].args.at(-1).length, "--result=".length + RESULT_LIMIT);
239 const dash = plan({ ...fixtures.subagentStop, last_assistant_message: "- Found 3 issues" }, {});
240 assert.equal(dash.steps[0].args.at(-1), "--result=- Found 3 issues", "a message that starts with a dash is still a value");
241 assert.equal(refusal(dash.steps[0].args), null);
242 });
243
244 test("an Agent call gives its subagent the task, and once finished its final message, and nothing else of its answer", () => {
245 const job = plan(fixtures.agentCompleted, {});
246 assert.deepEqual(job.subagent, {
247 id: "a4d2c8f1e0b3a297",
248 type: "Explore",
249 task: "Find API endpoints",
250 prompt: "Find all API endpoints",
251 model: "claude-sonnet-4-5",
252 result: "Found 12 endpoints in src/api.",
253 });
254 assert.deepEqual(job.steps, [{ args: ["session", "log", "--kind", "tool_call", "--", "Agent: Find API endpoints"] }]);
255 assert.ok(!JSON.stringify(job).includes("12450") && !JSON.stringify(job).includes("8320"));
256 const launched = plan(fixtures.agentLaunched, {});
257 assert.equal(launched.subagent.id, "b5");
258 assert.equal(launched.subagent.result, null, "a background subagent reports at SubagentStop");
259 assert.equal(plan(fixtures.agentCompleted, { G1T_RECORD_PROMPTS: "0" }).subagent.prompt, null);
260 assert.equal(agentResult({ content: "plain" }), "plain");
261 });
262
263 test("what a subagent does is its own session's, and the files it writes are touched", () => {
264 const job = plan(fixtures.inSubagent, {});
265 assert.deepEqual(job.agent, { id: "agent-def456", type: "Explore" });
266 assert.deepEqual(job.steps, [
267 { args: ["session", "log", "--kind", "tool_call", "--", "Edit: src/api/routes.ts"] },
268 { args: ["session", "touch", "--file=src/api/routes.ts"] },
269 ]);
270 assert.ok(!JSON.stringify(job).includes("SECRET PATCH"));
271 });
272
273 test("a skill is its name only", () => {
274 assert.deepEqual(plan(fixtures.skill, {}).steps, [{ args: ["session", "log", "--kind", "skill", "--", "work-on-issue"], skill: "work-on-issue" }]);
275 });
276
277 test("branches made, commits, claims and g1t's MCP tools are touched", () => {
278 const bash = (command) => plan({ ...base, hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command } }, {});
279 assert.deepEqual(bash("git checkout -b 42-fix").steps.at(-1), { args: ["session", "touch", "--branch", "42-fix"] });
280 assert.deepEqual(bash('git commit -m "x" --trailer "G1t-Session: $G1T_SESSION"').steps.at(-1), { touchHead: true });
281 assert.deepEqual(bash("g1t work claim 42").steps.at(-1), { args: ["session", "touch", "--issue", "42"] });
282 const mcp = plan({ ...base, hook_event_name: "PostToolUse", tool_name: "mcp__plugin_g1t_g1t__issue", tool_input: { action: "claim", repo: "a/b", number: 7 } }, {});
283 assert.equal(mcp.issue, 7);
284 assert.equal(branchFromCommand("git switch -c feat/x && echo"), "feat/x");
285 assert.equal(branchFromCommand("git branch -d old"), null);
286 assert.equal(isGitCommit("git -C repo commit -am x"), true);
287 assert.equal(g1tTool("mcp__g1t__session"), "session");
288 assert.equal(g1tTool("mcp__github__issue"), null);
289 });
290
291 test("a hand-off's issue comes with the session", () => {
292 assert.equal(plan({ ...base, hook_event_name: "SessionStart" }, { G1T_ISSUE: "12" }).issue, 12);
293 });
294});
295
296describe("summaries", () => {
297 test("say what a tool was called with, in one short line", () => {
298 assert.equal(summarizeTool("Edit", { file_path: "/work/repo/src/a.ts", old_string: "x", new_string: "y" }, "/work/repo"), "Edit: src/a.ts");
299 assert.equal(summarizeTool("Grep", { pattern: "TODO", path: "src" }, "/w"), "Grep: TODO in src");
300 // From the top of the working copy, wherever the shell has moved to.
301 assert.equal(repoPath("/work/repo/apps/web/app/a.ts", "/work/repo/apps/web", "/work/repo"), "apps/web/app/a.ts");
302 assert.equal(repoPath("app/a.ts", "/work/repo/apps/web", "/work/repo"), "apps/web/app/a.ts");
303 assert.equal(repoPath("/elsewhere/a.ts", "/work/repo/apps/web", "/work/repo"), null);
304 assert.equal(repoPath("/work/repo/src/a.ts", "/work/repo", null), "src/a.ts");
305 assert.equal(summarizeTool("WebFetch", { url: "https://example.com", prompt: "p" }), "WebFetch: https://example.com");
306 assert.equal(summarizeTool("Bash", { command: "echo one\necho two" }), "Bash: echo one …");
307 assert.equal(summarizeTool("mcp__g1t__issue", { action: "get", number: 4 }), "mcp__g1t__issue: get");
308 assert.ok(summarizeTool("Bash", { command: "y".repeat(1000) }).length <= 200);
309 });
310
311 test("hide what looks like a secret", () => {
312 const line = redact('curl -H "Authorization: Bearer g1t_abcdefghijklmnop" https://u:pw@x.com GITHUB_TOKEN=ghp_123456789012 --token abc');
313 assert.ok(!line.includes("abcdefghijklmnop"));
314 assert.ok(!line.includes("ghp_123456789012"));
315 assert.ok(!line.includes("u:pw@"));
316 assert.ok(!line.includes("--token abc"));
317 });
318
319 test("hide credentials wherever text is sent, and leave references alone", () => {
320 for (const [text, secret] of [
321 ["$env:G1T_TOKEN='abc123def456'; g1t whoami", "abc123def456"],
322 ["G1T_TOKEN=abc123def456 g1t whoami", "abc123def456"],
323 ['{"password": "hunter2!"}', "hunter2"],
324 ["curl -u admin:pa55word https://x", "pa55word"],
325 ["open https://x.com/cb?state=1&token=t0k3n", "t0k3n"],
326 ["jwt eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N", "dozjgNryP4J3"],
327 ["-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXktdjEAAAAABG5v\n-----END OPENSSH PRIVATE KEY-----", "b3BlbnNzaC1"], // g1t:allow-secret
328 ["here is my key: sk-ant-api03-abcDEF123456ghiJKL, use it", "abcDEF123456ghiJKL"],
329 ]) {
330 const out = redact(text);
331 assert.ok(!out.includes(secret), `${secret} in ${out}`);
332 assert.ok(out.includes("[redacted]"), out);
333 }
334 for (const kept of ["A path is not a secret: the rule read it as one", "password: the one you set", "TOKEN=$G1T_TOKEN", "token: ${{ secrets.DEPLOY }}", "fn f(token: String)", "npm_config_user_agent", "git show 58def4040e93a1dcda5f388f55360f3cd46cd97e"]) {
335 assert.equal(redact(kept), kept);
336 }
337 });
338
339 test("find the issue in a branch name", () => {
340 assert.equal(issueFromBranch("42-fix-login"), 42);
341 assert.equal(issueFromBranch("issue-7"), 7);
342 assert.equal(issueFromBranch("fix/123-thing"), 123);
343 assert.equal(issueFromBranch("main"), null);
344 assert.equal(issueFromBranch("release/1.2"), null);
345 assert.equal(issueFromBranch("HEAD"), null);
346 assert.equal(issueFromCommand("g1t session attach --issue 9"), 9);
347 assert.equal(issueFromCommand("g1t pr create --issue=12 --draft"), 12);
348 assert.equal(isGitPush("cd x && git -C repo push"), true);
349 assert.equal(isGitPush("git pushd"), false);
350 assert.equal(isG1tRemote(["remote.origin.url https://g1t.sh/a/b.git"], {}), true);
351 assert.equal(isG1tRemote(["remote.origin.url https://example.com/a/b.git"], {}), false);
352 assert.equal(isG1tRemote(["remote.origin.url https://git.acme.dev/a/b.git"], { G1T_HOST: "git.acme.dev" }), true);
353 });
354});
355
356describe("the plugin's files", () => {
357 const root = join(HERE, "..", "..", "..");
358 test("parse as JSON", () => {
359 for (const file of [".claude-plugin/marketplace.json", "plugins/claude-code/.claude-plugin/plugin.json", "plugins/claude-code/.mcp.json", "plugins/claude-code/hooks/hooks.json"]) {
360 assert.doesNotThrow(() => JSON.parse(readFileSync(join(root, file), "utf8")), file);
361 }
362 });
363
364 test("the AGENTS.md snippet is the one in the docs", () => {
365 const snippet = readFileSync(join(root, "plugins/other-harnesses/AGENTS.snippet.md"), "utf8").replaceAll("\r\n", "\n");
366 const guide = readFileSync(join(root, "apps/docs/src/content/docs/guides/claude-code-plugin.md"), "utf8").replaceAll("\r\n", "\n");
367 const block = /```md title="AGENTS.md"\n([\s\S]*?)```/.exec(guide)?.[1];
368 assert.equal(block, snippet);
369 });
370});
371
372describe("with a working copy", () => {
373 let dir, env, log;
374
375 const git = (...args) => spawnSync("git", args, { cwd: dir, encoding: "utf8" });
376 const allCalls = () =>
377 existsSync(log)
378 ? readFileSync(log, "utf8")
379 .trim()
380 .split("\n")
381 .filter(Boolean)
382 .map((l) => JSON.parse(l))
383 : [];
384 // The calls that do something: not the version check before them.
385 const calls = () => allCalls().filter((c) => c.args[0] !== "--version");
386
387 beforeEach(() => {
388 dir = mkdtempSync(join(tmpdir(), "g1t-hook-"));
389 log = join(dir, "calls.jsonl");
390 git("init", "-q", "-b", "42-fix-login");
391 git("remote", "add", "origin", "https://g1t.sh/acme/app.git");
392 env = { PATH: process.env.PATH, G1T_BIN: FAKE, FAKE_G1T_LOG: log, CLAUDE_PLUGIN_DATA: join(dir, ".data") };
393 });
394 afterEach(() => {
395 // Every call the hooks made is one the real CLI takes (the stand-in refuses the rest).
396 const refused = allCalls().filter((c) => refusal(c.args));
397 // And none let the CLI claim every uncommitted file as this session's (the stand-in logs `touch` then).
398 const guessing = allCalls().filter((c) => c.touch !== undefined);
399 rmSync(dir, { recursive: true, force: true, maxRetries: 20, retryDelay: 100 });
400 assert.deepEqual(refused, [], "the CLI refuses these calls");
401 assert.deepEqual(guessing, [], "these calls let the CLI guess what was touched");
402 });
403
404 test("SessionStart gives Claude the branch's issue's work context", () => {
405 const { output, job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart", source: "startup" }, env);
406 const context = output.hookSpecificOutput.additionalContext;
407 assert.equal(output.hookSpecificOutput.hookEventName, "SessionStart");
408 assert.match(context, /issue #42/);
409 assert.match(context, /Definition of done: it works/);
410 assert.deepEqual(calls()[0].args, ["work", "context", "42"]);
411 assert.equal(job.start, true);
412 });
413
414 test("the background half starts the session once, then logs into it", () => {
415 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
416 const { job } = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "fix the login" }, env);
417 // No SessionStart marked this session as one in a g1t working copy.
418 assert.equal(job, null);
419 work(plan({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "fix the login" }, env), env);
420 const [start, logged] = calls().filter((call) => call.args[1] !== "get_session");
421 assert.deepEqual(start.args, ["session", "start", "--harness", "claude_code", "--harness-session-id", "abc-123", "--json"]);
422 assert.deepEqual(logged, { args: ["session", "log", "--kind", "prompt", "--", "fix the login"], session: "ses_fake01" });
423 assert.equal(readFileSync(sessionFiles(base.session_id, env).id, "utf8"), "ses_fake01");
424 });
425
426 test("a shell command's writes are this session's; what was uncommitted before it is not", () => {
427 const { job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
428 work(job, env);
429 // Another session's edit, uncommitted in the same working copy.
430 writeFileSync(join(dir, "theirs.md"), "theirs");
431 const command = { ...base, cwd: dir, tool_name: "Bash", tool_use_id: "tu_1", tool_input: { command: "sed -i s/a/b/ mine.md" } };
432 hook({ ...command, hook_event_name: "PreToolUse" }, env);
433 writeFileSync(join(dir, "mine.md"), "mine");
434 const after = hook({ ...command, hook_event_name: "PostToolUse" }, env).job;
435 const touched = after.steps.filter((step) => step.args?.[1] === "touch").flatMap((step) => step.args.filter((arg) => arg.startsWith("--file=")));
436 assert.ok(touched.includes("--file=mine.md"), String(touched));
437 assert.ok(!touched.includes("--file=theirs.md"), String(touched));
438 // Read once: a command run again under the same id finds nothing kept.
439 assert.equal(existsSync(sessionFiles(base.session_id, env).shell("tu_1")), false);
440 });
441
442 test("the CLI never guesses touched files from the whole working copy", () => {
443 const { job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
444 work(job, env);
445 work(plan({ ...base, cwd: dir, hook_event_name: "Stop" }, env), env);
446 const heartbeat = calls().find((call) => call.args[0] === "session" && call.args[1] === "heartbeat");
447 assert.ok(heartbeat, "a heartbeat was sent");
448 assert.equal(heartbeat.touch, undefined);
449 });
450
451 test("background retrieval reaches the next tool without auto-acknowledging", () => {
452 // A CLI that acknowledges: an older one is told to update instead (below).
453 env.FAKE_G1T_VERSION = "0.3.3";
454 env.FAKE_G1T_UPDATES = JSON.stringify([{ id: "upd_real", kind: "overlap.detected", data: { paths: ["src/api.ts"] } }]);
455 const event = { ...base, cwd: dir, hook_event_name: "SessionStart" };
456 const { job } = hook(event, env);
457 work(job, env);
458 const next = { ...event, hook_event_name: "PreToolUse", tool_name: "Read", tool_input: { file_path: "src/api.ts" } };
459 const first = hook(next, env).output;
460 assert.match(first.hookSpecificOutput.additionalContext, /upd_real/);
461 assert.equal(first.hookSpecificOutput.hookEventName, "PreToolUse");
462 // The next tool is not told again at once; the next prompt is.
463 assert.equal(hook(next, env).output, null);
464 const prompt = hook({ ...event, hook_event_name: "UserPromptSubmit", prompt: "go on" }, env).output;
465 assert.match(prompt.hookSpecificOutput.additionalContext, /upd_real/);
466 assert.ok(calls().some((call) => call.args[1] === "get_session" && call.args.includes("after=4294967295")));
467 assert.ok(!calls().some((call) => call.args[1] === "record_session_entries"));
468 });
469
470 test("hooks after SessionStart record; SessionEnd forgets the session", () => {
471 hook({ ...base, cwd: dir, hook_event_name: "SessionStart", source: "startup" }, env);
472 const files = sessionFiles(base.session_id, env);
473 assert.ok(existsSync(files.marker));
474 const { job } = hook({ ...base, cwd: dir, hook_event_name: "Stop" }, env);
475 work(job, env);
476 work(plan({ ...base, cwd: dir, hook_event_name: "SessionEnd", reason: "clear" }, env), env);
477 const args = calls().map((c) => c.args.join(" "));
478 assert.ok(args.includes("session heartbeat"));
479 assert.ok(args.includes("session end --reason clear"));
480 assert.ok(!existsSync(files.marker) && !existsSync(files.id));
481 });
482
483 test("a push that reached the remote updates the head commit", () => {
484 git("-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false", "commit", "-q", "--allow-empty", "-m", "one");
485 git("update-ref", "refs/remotes/origin/42-fix-login", "HEAD");
486 const head = git("rev-parse", "HEAD").stdout.trim();
487 work(plan({ ...base, cwd: dir, hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command: "git push" } }, env), env);
488 const update = calls().find((c) => c.args[0] === "api");
489 assert.deepEqual(update.args, ["api", "update_session", "-f", "id=ses_fake01", "-f", `head_commit=${head}`, "--silent"]);
490 });
491
492 test("each subagent is a session of its own under this one, whatever order its hooks arrive in", () => {
493 const at = (event) => ({ ...event, cwd: dir });
494 hook(at({ ...base, hook_event_name: "SessionStart", source: "startup" }), env);
495 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
496 // Claude calls Agent; its task waits for the subagent.
497 const pre = hook(at({ ...base, hook_event_name: "PreToolUse", tool_name: "Agent", tool_input: fixtures.agentCompleted.tool_input }), env);
498 assert.equal(pre.output, null);
499 const started = hook(at(fixtures.subagentStart), env);
500 assert.match(started.output.hookSpecificOutput.additionalContext, /session of your own/);
501 assert.match(started.output.hookSpecificOutput.additionalContext, /g1t session list --issue 42 --subagents|g1t session list --subagents/);
502 assert.equal(started.job.pair, true, "paired with its Agent call in the background half");
503 work(started.job, env);
504 assert.equal(started.job.agent.task, "Find API endpoints", "no files of the subagent's: the oldest call of its type");
505 // What it does goes to its own session.
506 const edited = { ...fixtures.inSubagent.tool_input, file_path: join(dir, "src", "api", "routes.ts") };
507 work(hook(at({ ...fixtures.inSubagent, tool_input: edited }), env).job, env);
508 // Its g1t commands act as it.
509 const bash = hook(at({ ...base, hook_event_name: "PreToolUse", agent_id: "agent-def456", agent_type: "Explore", tool_name: "Bash", tool_input: { command: "g1t work claim 42" } }), env);
510 assert.equal(bash.output.hookSpecificOutput.updatedInput.command, "export G1T_SESSION=ses_sub_def456; g1t work claim 42");
511 const mcp = hook(at({ ...base, hook_event_name: "PreToolUse", agent_id: "agent-def456", tool_name: "mcp__plugin_g1t_g1t__issue", tool_input: { action: "claim", repo: "acme/app", number: 42 } }), env);
512 assert.equal(mcp.output.hookSpecificOutput.updatedInput.session_id, "ses_sub_def456");
513 // Outside a subagent, a command is left alone.
514 assert.equal(hook(at({ ...base, hook_event_name: "PreToolUse", tool_name: "Bash", tool_input: { command: "g1t work claim 42" } }), env).output, null);
515 work(hook(at(fixtures.subagentStop), env).job, env);
516 // A late SubagentStart starts it again, which g1t answers with the same, ended, session.
517 work(hook(at(fixtures.subagentStart), env).job, env);
518 const log = calls();
519 const childStarts = log.filter((c) => c.args[1] === "start" && c.args.includes("--parent"));
520 assert.ok(childStarts.length >= 2);
521 const first = childStarts[0].args;
522 assert.deepEqual(first.slice(0, 8), ["session", "start", "--harness", "claude_code", "--harness-session-id", "abc-123/agent/def456", "--parent", "ses_fake01"]);
523 assert.ok(first.includes("--no-remember"));
524 assert.ok(first.includes("--agent-type=Explore"));
525 assert.ok(first.includes("--task=Find API endpoints"));
526 const edit = log.find((c) => c.args[2] === "--kind" && c.args.at(-1) === "Edit: src/api/routes.ts");
527 assert.equal(edit.session, "ses_sub_def456");
528 const touched = log.find((c) => c.args[1] === "touch");
529 assert.deepEqual(touched, { args: ["session", "touch", "--file=src/api/routes.ts"], session: "ses_sub_def456" });
530 const ended = log.find((c) => c.args[1] === "end");
531 assert.deepEqual(ended, { args: ["session", "end", "--reason", "done", "--result=Analysis complete. Found 3 potential issues..."], session: "ses_sub_def456" });
532 });
533
534 test("five subagents of one type started at once each get their own Agent call's task, whatever order they start in", () => {
535 // Claude Code's transcript and, beside it, each subagent's files.
536 const transcript = join(dir, "projects", "abc-123.jsonl");
537 const subagents = join(dir, "projects", "abc-123", "subagents");
538 mkdirSync(subagents, { recursive: true });
539 writeFileSync(transcript, "");
540 const at = (event) => ({ ...event, cwd: dir, transcript_path: transcript });
541 hook(at({ ...base, hook_event_name: "SessionStart" }), env);
542 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
543 const n = [1, 2, 3, 4, 5];
544 // One message, five Agent calls of the same type.
545 for (const i of n) {
546 const tool_input = { description: `Task ${i}`, prompt: `Do thing ${i}, and only thing ${i}.`, subagent_type: "general-purpose" };
547 hook(at({ ...base, hook_event_name: "PreToolUse", tool_name: "Agent", tool_input, tool_use_id: `toolu_${i}` }), env);
548 }
549 const files = (i, { meta = true, first = true } = {}) => {
550 if (meta) writeFileSync(join(subagents, `agent-a${i}.meta.json`), JSON.stringify({ agentType: "general-purpose", description: `Task ${i}`, toolUseId: `toolu_${i}` }));
551 if (first) writeFileSync(join(subagents, `agent-a${i}.jsonl`), `${JSON.stringify({ type: "user", agentId: `a${i}`, message: { role: "user", content: `Do thing ${i}, and only thing ${i}.` } })}\n{"type":"attachment"}\n`);
552 };
553 // They start in another order: one with its meta file, one with only its transcript (by prompt), the rest with both.
554 files(4);
555 files(2, { meta: false });
556 files(5);
557 files(1);
558 files(3, { first: false });
559 for (const i of [4, 2, 5, 1, 3]) work(hook(at({ ...base, hook_event_name: "SubagentStart", agent_id: `a${i}`, agent_type: "general-purpose" }), env).job, env);
560 const starts = calls().filter((c) => c.args[1] === "start" && c.args.includes("--parent"));
561 assert.equal(starts.length, 5);
562 for (const i of n) {
563 const start = starts.find((c) => c.args.includes(`abc-123/agent/a${i}`)).args;
564 assert.ok(start.includes(`--task=Task ${i}`), `subagent ${i}: ${start.join(" ")}`);
565 assert.ok(start.includes(`--prompt=Do thing ${i}, and only thing ${i}.`), `subagent ${i}'s own prompt`);
566 }
567 assert.equal(readdirSync(join(env.CLAUDE_PLUGIN_DATA, "sessions")).filter((f) => f.includes(".task.")).length, 0, "every task taken once");
568 });
569
570 test("a pending task is never handed to two subagents, and an exact subagent never takes another's", () => {
571 const files = sessionFiles(base.session_id, env);
572 const input = (i) => ({ description: `Task ${i}`, prompt: `Prompt ${i}`, subagent_type: "general-purpose" });
573 for (const i of [1, 2, 3]) rememberTask(files, input(i), `toolu_${i}`);
574 assert.equal(takeTask(files, { type: "general-purpose", toolUseId: "toolu_2" }).task, "Task 2");
575 assert.equal(takeTask(files, { type: "general-purpose", toolUseId: "toolu_2" }), null, "taken once");
576 assert.equal(takeTask(files, { type: "general-purpose", prompt: "Prompt 2" }), null, "nor by its prompt");
577 assert.equal(takeTask(files, { type: "general-purpose", toolUseId: "toolu_9" }), null, "an unknown call takes nothing rather than a guess");
578 assert.equal(takeTask(files, { type: "general-purpose", prompt: " Prompt 3\n" }).task, "Task 3", "the prompt as the transcript has it");
579 // With no files of the subagent's (an older Claude Code): the oldest of its type, as before.
580 assert.equal(takeTask(files, "general-purpose").task, "Task 1");
581 assert.equal(takeTask(files, "general-purpose"), null);
582 // An Agent call answered takes its own task back, so no later subagent guesses it.
583 rememberTask(files, input(4), "toolu_4");
584 work({ ...plan({ ...fixtures.agentLaunched, cwd: dir, tool_use_id: "toolu_4" }, env) }, env);
585 assert.equal(takeTask(files, "general-purpose"), null);
586 });
587
588 test("a subagent's files give its task even when its Agent call was not kept", () => {
589 const subagents = join(dir, "t", "subagents");
590 mkdirSync(subagents, { recursive: true });
591 writeFileSync(join(subagents, "agent-a7.meta.json"), JSON.stringify({ description: "Look around", toolUseId: "toolu_7" }));
592 writeFileSync(join(subagents, "agent-a7.jsonl"), `${JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: "Look around the repo" }] } })}\n`);
593 const files = sessionFiles(base.session_id, env);
594 rememberTask(files, { description: "Someone else's", prompt: "not yours", subagent_type: "Explore" }, "toolu_8");
595 const agent = pairSubagent({ id: "agent-a7", type: "Explore" }, files, join(dir, "t.jsonl"), env);
596 assert.deepEqual(agent, { id: "agent-a7", type: "Explore", task: "Look around", prompt: "Look around the repo" });
597 assert.equal(takeTask(files, "Explore").task, "Someone else's", "left for its own subagent");
598 assert.equal(pairSubagent({ id: "a7", type: "Explore" }, files, join(dir, "t.jsonl"), { G1T_RECORD_PROMPTS: "0" }).prompt, undefined);
599 });
600
601 test("a session started with no g1t remote is recorded once a command adds one, titled by its first prompt", () => {
602 git("remote", "remove", "origin");
603 const at = (event) => ({ ...base, cwd: dir, ...event });
604 assert.deepEqual(hook(at({ hook_event_name: "SessionStart", source: "startup" }), env), { output: null, job: null });
605 assert.equal(hook(at({ hook_event_name: "UserPromptSubmit", prompt: "Build me a todo app. Use React." }), env).job, null);
606 assert.equal(hook(at({ hook_event_name: "UserPromptSubmit", prompt: "and make it blue" }), env).job, null);
607 const bash = (command) => at({ hook_event_name: "PostToolUse", tool_name: "Bash", tool_input: { command } });
608 assert.equal(hook(at({ hook_event_name: "PostToolUse", tool_name: "Write", tool_input: { file_path: join(dir, "a.ts") } }), env).job, null);
609 assert.equal(hook(bash("npm init -y"), env).job, null);
610 assert.equal(hook(bash("git remote -v"), env).job, null, "looked, and there is none yet");
611 assert.deepEqual(calls(), [], "nothing recorded without a g1t remote");
612 // The agent makes the repository and adds it as the remote.
613 git("remote", "add", "origin", "https://g1t.sh/acme/app.git");
614 const { output, job } = hook(bash("g1t repo create acme/app --private && git remote add origin https://g1t.sh/acme/app.git"), env);
615 assert.equal(job.start, true);
616 assert.equal(output.hookSpecificOutput.hookEventName, "PostToolUse");
617 assert.match(output.hookSpecificOutput.additionalContext, /issue #42/, "told what SessionStart would have told it");
618 assert.deepEqual(job.steps.at(-1), { title: "Build me a todo app" });
619 work(job, env);
620 const recorded = calls().filter((c) => c.args[0] === "session");
621 assert.deepEqual(recorded[0].args, ["session", "start", "--harness", "claude_code", "--harness-session-id", "abc-123", "--json"]);
622 assert.ok(recorded.some((c) => c.args[1] === "log" && c.args.at(-1).startsWith("Bash: g1t repo create acme/app")));
623 assert.ok(recorded.some((c) => c.args.join(" ") === "session attach --title=Build me a todo app"));
624 // From here on it is recorded like any other, and titled once.
625 const next = hook(at({ hook_event_name: "UserPromptSubmit", prompt: "Now add tests" }), env).job;
626 assert.ok(next && !next.steps.some((s) => s.title) && !next.start);
627 });
628
629 test("a session given a g1t remote between prompts is recorded at the next one", () => {
630 git("remote", "set-url", "origin", "https://example.com/acme/app.git");
631 const at = (event) => ({ ...base, cwd: dir, ...event });
632 hook(at({ hook_event_name: "SessionStart" }), env);
633 assert.equal(hook(at({ hook_event_name: "UserPromptSubmit", prompt: "/clear" }), env).job, null);
634 git("remote", "set-url", "origin", "https://g1t.sh/acme/app.git");
635 const { job } = hook(at({ hook_event_name: "UserPromptSubmit", prompt: "fix the login" }), env);
636 assert.equal(job.start, true);
637 assert.deepEqual(job.steps.at(-1), { title: "Fix the login" }, "no earlier prompt said what it is for: this one does");
638 assert.ok(existsSync(sessionFiles(base.session_id, env).marker));
639 assert.ok(!existsSync(sessionFiles(base.session_id, env).unrecorded));
640 });
641
642 test("only commands that may add a remote look for one", () => {
643 for (const command of ["git remote add origin https://g1t.sh/a/b.git", "git -C app push -u origin main", "git init", "g1t repo create a/b", "cd x && git clone https://g1t.sh/a/b"]) {
644 assert.equal(mayAddRemote(command), true, command);
645 }
646 for (const command of ["git status", "npm install", "g1t work list", "echo push", undefined]) assert.equal(mayAddRemote(command), false, String(command));
647 });
648
649 test("a subagent whose stop arrives first is started, then ended", () => {
650 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
651 work(hook({ ...fixtures.subagentStop, cwd: dir }, env).job, env);
652 const [, start, end] = calls().filter((c) => c.args[0] === "session");
653 assert.ok(start.args.includes("--parent"));
654 assert.equal(end.args[1], "end");
655 assert.equal(end.session, "ses_sub_def456");
656 });
657
658 test("an Agent call that finished ends its subagent with what it reported", () => {
659 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
660 work(hook({ ...fixtures.agentCompleted, cwd: dir }, env).job, env);
661 const log = calls().filter((c) => c.args[0] === "session");
662 assert.equal(log.find((c) => c.args[1] === "log").session, "ses_fake01", "the Agent call is the parent's");
663 const end = log.find((c) => c.args[1] === "end");
664 assert.deepEqual(end, { args: ["session", "end", "--reason", "done", "--result=Found 12 endpoints in src/api."], session: "ses_sub_a4d2c8f1e0b3a297" });
665 });
666
667 test("a hand-off names its issue at the start", () => {
668 git("checkout", "-q", "-b", "main");
669 const { output, job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, { ...env, G1T_ISSUE: "12" });
670 assert.match(output.hookSpecificOutput.additionalContext, /issue #12 \(from the work handed to it\)/);
671 assert.match(output.hookSpecificOutput.additionalContext, /G1t-Session/);
672 work(job, env);
673 const start = calls().find((c) => c.args[1] === "start");
674 assert.ok(start.args.includes("--issue") && start.args.includes("12"));
675 });
676
677 test("a missing CLI records nothing and says so once", () => {
678 const missing = { ...env, G1T_BIN: join(dir, "no-such-g1t") };
679 const first = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, missing);
680 assert.match(first.output.systemMessage, /not installed/);
681 assert.equal(first.job, null);
682 const second = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, missing);
683 assert.equal(second.output, null);
684 assert.equal(hook({ ...base, cwd: dir, hook_event_name: "Stop" }, missing).job, null);
685 assert.deepEqual(calls(), []);
686 });
687
688 test("a signed-out CLI is said once, at the next prompt", () => {
689 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, { ...env, CLAUDE_PLUGIN_DATA: env.CLAUDE_PLUGIN_DATA });
690 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, { ...env, FAKE_G1T_EXIT: "4" });
691 const first = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, env);
692 assert.match(first.output.systemMessage, /not signed in/);
693 const second = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, env);
694 assert.equal(second.output, null);
695 });
696
697 test("outside a g1t repository nothing happens", () => {
698 git("remote", "set-url", "origin", "https://example.com/acme/app.git");
699 const { output, job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
700 assert.equal(output, null);
701 assert.equal(job, null);
702 assert.equal(hook({ ...base, cwd: dir, hook_event_name: "Stop" }, env).job, null);
703 assert.deepEqual(calls(), []);
704 });
705
706 test("the script answers SessionStart on stdin quickly, as JSON", async () => {
707 const started = Date.now();
708 const out = spawnSync(process.execPath, [SCRIPT], {
709 input: JSON.stringify({ ...base, cwd: dir, hook_event_name: "SessionStart", source: "startup" }),
710 encoding: "utf8",
711 env: { ...process.env, ...env },
712 });
713 const took = Date.now() - started;
714 assert.equal(out.status, 0);
715 assert.match(JSON.parse(out.stdout).hookSpecificOutput.additionalContext, /issue #42/);
716 assert.ok(took < 3000, `took ${took} ms`);
717 // The detached half starts the session after the hook has returned.
718 const id = sessionFiles(base.session_id, env).id;
719 for (let i = 0; i < 100 && !existsSync(id); i++) await new Promise((done) => setTimeout(done, 50));
720 assert.equal(readFileSync(id, "utf8"), "ses_fake01");
721 await new Promise((done) => setTimeout(done, 200));
722 });
723
724 test("the script prints nothing for a prompt, and never fails on bad input", () => {
725 const prompt = spawnSync(process.execPath, [SCRIPT], {
726 input: JSON.stringify({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hello" }),
727 encoding: "utf8",
728 env: { ...process.env, ...env },
729 });
730 assert.equal(prompt.status, 0);
731 assert.equal(prompt.stdout, "");
732 const bad = spawnSync(process.execPath, [SCRIPT], { input: "not json", encoding: "utf8", env: { ...process.env, ...env } });
733 assert.equal(bad.status, 0);
734 assert.equal(bad.stdout, "");
735 });
736
737 test("a CLI older than the plugin needs records nothing and says so once, with how to update it", () => {
738 const old = { ...env, FAKE_G1T_VERSION: "0.3.1" };
739 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, old);
740 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, old);
741 work(plan({ ...base, cwd: dir, hook_event_name: "Stop" }, old), old);
742 // SessionStart still asks it for the issue's context, which every CLI gives.
743 assert.deepEqual(calls().map((c) => c.args.join(" ")), ["work context 42"], "nothing is recorded with it");
744 assert.equal(allCalls().filter((c) => c.args[0] === "--version").length, 1, "the version is asked once for each build of the CLI");
745 const first = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, old);
746 assert.match(first.output.systemMessage, /g1t CLI is 0\.3\.1, and the plugin needs 0\.3\.2 or later/);
747 assert.match(first.output.systemMessage, /curl -fsSL https:\/\/g1t\.sh\/install \| sh/);
748 assert.match(first.output.systemMessage, /irm https:\/\/g1t\.sh\/install\.ps1 \| iex/);
749 assert.equal(hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, old).output, null);
750 assert.equal(older("0.3.1", MIN_CLI), true);
751 assert.equal(older("0.3.2", MIN_CLI), false);
752 assert.equal(older("0.10.0", MIN_CLI), false);
753 assert.equal(older("1.0.0", MIN_CLI), false);
754 });
755
756 test("a CLI that refuses a command (exit 2) is said once, as one to update", () => {
757 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
758 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, { ...env, FAKE_G1T_EXIT: "2" });
759 const first = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, env);
760 assert.match(first.output.systemMessage, /refused `g1t session start`/);
761 assert.match(first.output.systemMessage, /installer again/);
762 assert.equal(hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "hi" }, env).output, null);
763 });
764
765 test("the stand-in CLI refuses what the real one refuses", () => {
766 assert.equal(CONTRACT.minimum_version, MIN_CLI, "the hooks ask for the CLI the contract needs");
767 assert.match(refusal(["session", "log", "--kind", "tool-calls", "--", "x"]), /takes prompt, tool_call, skill/);
768 assert.match(refusal(["session", "log", "--kind", "note", "--", "x"]), /not note/, "the hooks never send a note");
769 assert.match(refusal(["session", "end", "--result", "- a list"]), /unexpected argument/);
770 assert.equal(refusal(["session", "end", "--result=- a list"]), null);
771 assert.match(refusal(["session", "touch"]), /needs one of/);
772 assert.match(refusal(["session", "heartbeat", "--now"]), /takes no --now/);
773 assert.match(refusal(["session", "start", "--harness", "claude-managed-agents", "--harness-session-id", "x"]), /takes claude_code/);
774 assert.match(refusal(["work", "context", "abc"]), /not abc/);
775 assert.match(refusal(["session", "pause"]), /takes 0 argument/);
776 assert.equal(refusal(["api", "update_session", "-f", "id=ses_1", "-f", "head_commit=abc", "--silent"]), null);
777 });
778
779 test("PowerShell commands are read as Bash ones are, and a subagent's act as its session", () => {
780 const ps = (command, extra = {}) => ({ ...base, cwd: dir, hook_event_name: "PostToolUse", tool_name: "PowerShell", tool_input: { command }, ...extra });
781 assert.equal(plan(ps("g1t work claim 42"), env).issue, 42);
782 assert.deepEqual(plan(ps("git checkout -b 42-fix; git status"), env).steps.at(-1), { args: ["session", "touch", "--branch", "42-fix"] });
783 assert.deepEqual(plan(ps("git commit -m x"), env).steps.at(-1), { touchHead: true });
784 assert.deepEqual(plan(ps("git push origin 42-fix"), env).steps.at(-1), { headCommit: true });
785 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
786 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
787 work(hook({ ...fixtures.subagentStart, cwd: dir }, env).job, env);
788 const pre = (tool_name, command) =>
789 hook({ ...base, cwd: dir, hook_event_name: "PreToolUse", agent_id: "agent-def456", agent_type: "Explore", tool_name, tool_input: { command } }, env).output;
790 assert.equal(pre("PowerShell", "g1t work claim 42").hookSpecificOutput.updatedInput.command, "$env:G1T_SESSION='ses_sub_def456'; g1t work claim 42");
791 assert.equal(pre("PowerShell", "g1t.exe session view").hookSpecificOutput.updatedInput.command, "$env:G1T_SESSION='ses_sub_def456'; g1t.exe session view");
792 assert.equal(pre("Bash", "echo $G1T_SESSION").hookSpecificOutput.updatedInput.command, "export G1T_SESSION=ses_sub_def456; echo $G1T_SESSION");
793 assert.equal(pre("PowerShell", "$env:G1T_SESSION='ses_other'; g1t work claim 42"), null, "a session the command sets itself is kept");
794 assert.equal(pre("PowerShell", "Get-ChildItem"), null, "other commands are left alone");
795 // The tool call is recorded as Claude wrote it.
796 const after = plan(ps("$env:G1T_SESSION='ses_sub_def456'; g1t work claim 42", { agent_id: "agent-def456" }), env);
797 assert.deepEqual(after.steps[0].args.at(-1), "PowerShell: g1t work claim 42");
798 assert.equal(summarizeTool("Bash", { command: "export G1T_SESSION=ses_1; g1t pr view" }), "Bash: g1t pr view");
799 });
800
801 test("a skill typed as /plugin:name is recorded once in its turn, however Claude Code then runs it", () => {
802 assert.equal(typedSkill("/g1t:work-on-issue 42"), "g1t:work-on-issue");
803 assert.equal(typedSkill("/g1t:status"), "g1t:status");
804 assert.equal(typedSkill("/clear"), null, "Claude Code's own commands are not skills");
805 assert.equal(typedSkill("look at /g1t:status"), null);
806 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
807 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
808 const typed = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "/g1t:work-on-issue 42" }, env).job;
809 assert.deepEqual(typed.steps.map((s) => s.args.slice(0, 4)), [["session", "log", "--kind", "prompt"], ["session", "log", "--kind", "skill"]]);
810 work(typed, env);
811 const tool = hook({ ...base, cwd: dir, hook_event_name: "PostToolUse", tool_name: "Skill", tool_input: { skill: "g1t:work-on-issue", args: "42" } }, env).job;
812 work(tool, env);
813 const skills = calls().filter((c) => c.args.includes("skill"));
814 assert.equal(skills.length, 2);
815 assert.deepEqual(skills[0].args, ["session", "log", "--kind", "skill", "--key=skill:work-on-issue:1", "--", "g1t:work-on-issue"]);
816 assert.equal(skills[1].args[4], "--key=skill:work-on-issue:1", "the same key: g1t keeps the first");
817 // Another skill in the turn has a key of its own; the next prompt is another turn.
818 const next = hook({ ...base, cwd: dir, hook_event_name: "PostToolUse", tool_name: "Skill", tool_input: { skill: "g1t:coordinate" } }, env).job;
819 assert.equal(next.steps[0].key, "skill:coordinate:1");
820 hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "go on" }, { ...env, G1T_RECORD_PROMPTS: "0" });
821 const later = hook({ ...base, cwd: dir, hook_event_name: "PostToolUse", tool_name: "Skill", tool_input: { skill: "g1t:work-on-issue" } }, env).job;
822 assert.equal(later.steps[0].key, "skill:work-on-issue:2", "a turn whose prompt is not sent is still a turn");
823 // Prompts kept back: the typed skill's name is still recorded, the prompt is not.
824 const quiet = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "/g1t:status" }, { ...env, G1T_RECORD_PROMPTS: "0" }).job;
825 assert.deepEqual(quiet.steps.map((s) => s.args.at(-1)), ["g1t:status"]);
826 });
827
828 test("with no issue in sight, Claude is told the session is recorded and when to open or claim one", () => {
829 git("symbolic-ref", "HEAD", "refs/heads/fix-previews");
830 const { output } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart", source: "startup" }, env);
831 const context = output.hookSpecificOutput.additionalContext;
832 assert.match(context, /this session is recorded on g1t and shows to the team/);
833 assert.match(context, /Just work/);
834 assert.match(context, /`g1t work claim --title "…"`/);
835 assert.match(context, /Never open issues for questions, exploration or trivial fixes/);
836 assert.match(context, /retitle it in a few words with `g1t session attach --title "…"`/);
837 assert.ok(context.length < 1100, `injected every session, so short: ${context.length}`);
838 assert.ok(!calls().some((c) => c.args[0] === "work"), "no issue's context is asked for");
839 });
840
841 test("Claude is reminded to retitle the session at its second prompt and every fifth after, no more", () => {
842 assert.deepEqual(
843 Array.from({ length: 16 }, (_, i) => i + 1).filter((turn) => retitleNudge(turn)),
844 [2, 5, 10, 15],
845 );
846 assert.match(retitleNudge(2), /g1t session attach --title/);
847 });
848
849 test("the session's first prompt with an intent titles it, once, and never over a title it has", () => {
850 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
851 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
852 const prompt = (text, more = {}) => hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: text }, { ...env, ...more }).job;
853 // A slash command says nothing of what the session is for.
854 work(prompt("/clear"), env);
855 assert.ok(!calls().some((c) => c.args[1] === "attach" || c.args[1] === "heartbeat"));
856 work(prompt("[TEST] fix the preview builds. They time out."), env);
857 const titled = calls().filter((c) => c.args[1] === "heartbeat" || c.args[1] === "attach");
858 assert.deepEqual(titled, [
859 { args: ["session", "heartbeat", "--json"], session: "ses_fake01" },
860 { args: ["session", "attach", "--title=[TEST] fix the preview builds"], session: "ses_fake01" },
861 ]);
862 // Later prompts do not try again.
863 const next = prompt("now the tests");
864 assert.ok(!next.steps.some((s) => s.title));
865 });
866
867 test("a session titled already keeps its title", () => {
868 hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, env);
869 work({ cwd: dir, sid: base.session_id, start: true, steps: [] }, env);
870 const job = hook({ ...base, cwd: dir, hook_event_name: "UserPromptSubmit", prompt: "fix the login" }, env).job;
871 work(job, { ...env, FAKE_G1T_TITLE: "Rewrite the auth flow" });
872 assert.ok(calls().some((c) => c.args[1] === "heartbeat"));
873 assert.ok(!calls().some((c) => c.args[1] === "attach"), "a title set before is never replaced");
874 });
875
876 test("Claude's own commands get the session's id once it has started", () => {
877 const envFile = join(dir, "env.sh");
878 const { job } = hook({ ...base, cwd: dir, hook_event_name: "SessionStart" }, { ...env, CLAUDE_ENV_FILE: envFile });
879 assert.ok(!existsSync(envFile), "nothing is written before the session's id is known");
880 work(job, env);
881 // A plain assignment: Claude Code gives it to PowerShell commands too.
882 assert.equal(readFileSync(envFile, "utf8"), "export G1T_SESSION=ses_fake01\nexport G1T_TOUCH=0\n");
883 });
884
885 test("on a Node older than 18 nothing is recorded, and that is said once", () => {
886 const at = (hook_event_name) => ({ ...base, cwd: dir, hook_event_name });
887 assert.equal(oldNode(at("SessionStart"), env, "18.0.0"), undefined);
888 const first = oldNode(at("SessionStart"), env, "16.20.2");
889 assert.match(first.systemMessage, /need Node 18 or later, and `node` is v16\.20\.2/);
890 assert.equal(oldNode(at("UserPromptSubmit"), env, "16.20.2"), null);
891 assert.equal(oldNode(at("PostToolUse"), env, "16.20.2"), null);
892 assert.deepEqual(calls(), []);
893 });
894});
895
896test("pending updates survive delivery and stay isolated between parent and child", () => {
897 const dir = mkdtempSync(join(tmpdir(), "g1t-inbox-"));
898 try {
899 const env = { CLAUDE_PLUGIN_DATA: dir };
900 const files = sessionFiles("harness", env);
901 mkdirSync(files.dir, { recursive: true });
902 writeFileSync(files.id, "ses_parent");
903 writeFileSync(files.agent("child"), "ses_child");
904 writeFileSync(files.updates("ses_parent"), JSON.stringify([{ id: "parent-update", kind: "overlap.detected", data: {} }]));
905 writeFileSync(files.updates("ses_child"), JSON.stringify([{ id: "child-update", kind: "dependency.changed", data: {} }]));
906 const event = { session_id: "harness" };
907 const first = updateContext(event, env);
908 assert.match(first, /parent-update/);
909 assert.doesNotMatch(first, /child-update/);
910 assert.equal(updateContext(event, env), first);
911 // Before tools: shown once, again when it changes or after a while.
912 const files2 = sessionFiles("harness", env);
913 rmSync(files2.shown("ses_parent"), { force: true });
914 assert.equal(updateContext(event, env, { throttle: true, now: 1000 }), first);
915 assert.equal(updateContext(event, env, { throttle: true, now: 2000 }), null);
916 assert.equal(updateContext(event, env, { throttle: true, now: 1000 + UPDATES_REPEAT_MS }), first);
917 writeFileSync(files.updates("ses_parent"), JSON.stringify([{ id: "parent-update", kind: "overlap.detected", data: {} }, { id: "newer", kind: "work.claimed", data: {} }]));
918 assert.match(updateContext(event, env, { throttle: true, now: 1001 + UPDATES_REPEAT_MS }), /newer/);
919 writeFileSync(files.updates("ses_parent"), JSON.stringify([{ id: "parent-update", kind: "overlap.detected", data: {} }]));
920 const child = updateContext({ ...event, agent_id: "child" }, env);
921 assert.match(child, /child-update/);
922 assert.doesNotMatch(child, /parent-update/);
923 assert.equal(updateContext({ ...event, agent_id: "unknown" }, env), null);
924 writeFileSync(files.updates("ses_parent"), JSON.stringify([{ id: "oversized", data: "x".repeat(20000) }]));
925 const bounded = updateContext(event, env);
926 assert.ok(bounded.length < 10000);
927 assert.match(bounded, /read get_session first/);
928 // A payload that was omitted is not cleared from the cache.
929 assert.match(readFileSync(files.updates("ses_parent"), "utf8"), /oversized/);
930 writeFileSync(files.updates("ses_parent"), "[]");
931 assert.equal(updateContext(event, env), null);
932 assert.equal(updateContext({ ...event, agent_id: "child" }, env), child);
933 } finally { rmSync(dir, { recursive: true, force: true }); }
934});
935
936test("a CLI too old to acknowledge is told to update, once per set of updates", () => {
937 const dir = mkdtempSync(join(tmpdir(), "g1t-stuck-"));
938 try {
939 const env = { CLAUDE_PLUGIN_DATA: dir };
940 const files = sessionFiles("harness", env);
941 mkdirSync(files.dir, { recursive: true });
942 writeFileSync(files.id, "ses_old");
943 writeFileSync(join(dir, "cli.json"), JSON.stringify({ stamp: "x", version: "0.3.2" }));
944 writeFileSync(files.updates("ses_old"), JSON.stringify([{ id: "upd_1", kind: "session.ended", data: {} }]));
945 const event = { session_id: "harness" };
946 const first = updateContext(event, env);
947 assert.match(first, /upd_1/);
948 assert.match(first, /cannot acknowledge them \(0\.3\.3 can\)/);
949 assert.match(first, /install\.ps1/, "0.3.2 has no g1t upgrade: the installer");
950 assert.doesNotMatch(first, /g1t session acknowledge/);
951 // Nothing can clear them, so not again on every prompt or tool.
952 assert.equal(updateContext(event, env), null);
953 assert.equal(updateContext(event, env, { throttle: true, now: Date.now() + 10 * UPDATES_REPEAT_MS }), null);
954 writeFileSync(files.updates("ses_old"), JSON.stringify([{ id: "upd_1", data: {} }, { id: "upd_2", data: {} }]));
955 assert.match(updateContext(event, env), /upd_2/);
956 // A CLI that acknowledges is asked to.
957 writeFileSync(join(dir, "cli.json"), JSON.stringify({ stamp: "x", version: "0.3.3" }));
958 assert.match(updateContext(event, env), /g1t session acknowledge UPDATE_ID --session ses_old/);
959 assert.equal(howToUpdate("0.3.4"), "`g1t upgrade`");
960 assert.match(howToUpdate("0.3.3"), /curl -fsSL https:\/\/g1t\.sh\/install \| sh/);
961 assert.match(howToUpdate(null), /installer/);
962 } finally { rmSync(dir, { recursive: true, force: true }); }
963});
964
965test("an acknowledgement refreshes the inbox at once, from the shell or MCP", () => {
966 const dir = mkdtempSync(join(tmpdir(), "g1t-ack-"));
967 try {
968 const env = { CLAUDE_PLUGIN_DATA: dir };
969 const base = { session_id: "harness", cwd: dir, hook_event_name: "PostToolUse" };
970 const shell = plan({ ...base, tool_name: "Bash", tool_input: { command: "g1t session acknowledge upd_1 --note 'Separate scopes'" } }, env);
971 assert.equal(shell.refreshUpdates, true);
972 const mcp = plan({ ...base, tool_name: "mcp__plugin_g1t_g1t__session", tool_input: { action: "record", id: "ses_a", acknowledge: ["upd_1"] } }, env);
973 assert.equal(mcp.refreshUpdates, true);
974 const other = plan({ ...base, tool_name: "Bash", tool_input: { command: "git status" } }, env);
975 assert.equal(other.refreshUpdates, undefined);
976 } finally { rmSync(dir, { recursive: true, force: true }); }
977});