@helmiq/crew 0.1.0 → 0.2.1

package/bin/crew.cjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+
+let cliEntry;
+try {
+  cliEntry = path.join(
+    path.dirname(require.resolve('@helmiq/crew-cli/package.json')),
+    'dist',
+    'index.js',
+  );
+} catch {
+  console.error('crew: @helmiq/crew-cli is not installed.');
+  console.error('');
+  console.error('  npm install @helmiq/crew @helmiq/crew-cli');
+  console.error('  # or');
+  console.error('  pnpm add @helmiq/crew @helmiq/crew-cli');
+  process.exit(1);
+}
+
+try {
+  execFileSync(process.execPath, [cliEntry, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+  });
+} catch (e) {
+  if (e && e.status) process.exit(e.status);
+  throw e;
+}

package/defaults/personas/engineer.persona.yaml

@@ -15,6 +15,7 @@ persona:
     - test-write
     - self-review
     - pr-author
+    - ci-check
 
   perception:
     always_read:
@@ -59,13 +60,13 @@ persona:
           skill: test-write
           reads: [code-changes, requirements]
           produces: test-files
-          tools: [code, git, shell]
+          tools: [code, git-read, git-commit, shell]
 
         - name: quality-checker
           skill: quality-check
           reads: [code-changes, test-files]
           produces: quality-report
-          tools: [shell, code, git]
+          tools: [shell, code, git-read, git-commit]
           max_iterations: 3
 
         - name: self-reviewer
@@ -82,7 +83,14 @@ persona:
           produces: pull-request
           tools: [git]
 
-      published_artifact: pull-request
+        - name: ci-checker
+          skill: ci-check
+          reads: [pull-request, code-changes]
+          produces: ci-report
+          tools: [git, shell, code]
+          max_iterations: 3
+
+      published_artifact: ci-report
       quality_gate: human-review
 
     address-feedback:
@@ -104,7 +112,7 @@ persona:
           skill: quality-check
           reads: [code-changes]
           produces: quality-report
-          tools: [shell, code, git]
+          tools: [shell, code, git-read, git-commit]
           max_iterations: 3
 
       published_artifact: code-changes

package/dist/config/config.test.js

@@ -324,13 +324,14 @@ describe('T-FR-01-1: default Engineer persona spec schema validation', () => {
         expect(spec.persona.skills).toContain('test-write');
         expect(spec.persona.skills).toContain('self-review');
         expect(spec.persona.skills).toContain('pr-author');
+        expect(spec.persona.skills).toContain('ci-check');
     });
-    it('defines implement-story as a composite task with six sub-agents', () => {
+    it('defines implement-story as a composite task with seven sub-agents', () => {
         const task = spec.persona.tasks['implement-story'];
         expect(task).toBeDefined();
         expect(task.mode).toBe('composite');
         const composite = task;
-        expect(composite.sub_agents).toHaveLength(6);
+        expect(composite.sub_agents).toHaveLength(7);
         const names = composite.sub_agents.map((a) => a.name);
         expect(names).toEqual([
             'planner',
@@ -339,6 +340,7 @@ describe('T-FR-01-1: default Engineer persona spec schema validation', () => {
             'quality-checker',
             'self-reviewer',
             'pr-author',
+            'ci-checker',
         ]);
     });
     it('maps sub-agents to skills', () => {
@@ -350,6 +352,7 @@ describe('T-FR-01-1: default Engineer persona spec schema validation', () => {
         expect(byName['quality-checker']).toBe('quality-check');
         expect(byName['self-reviewer']).toBe('self-review');
         expect(byName['pr-author']).toBe('pr-author');
+        expect(byName['ci-checker']).toBe('ci-check');
     });
 });
 describe('T-FR-01-2: skill resolution', () => {
@@ -490,19 +493,62 @@ llm:
         }
     });
 });
+describe('T-CREW-10-003: ci-checker sub-agent configuration', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
+    });
+    it('ci-checker references the ci-check skill', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const ci = task.sub_agents.find((a) => a.name === 'ci-checker');
+        expect(ci).toBeDefined();
+        expect(ci.skill).toBe('ci-check');
+    });
+    it('ci-checker has git, shell, and code tools', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const ci = task.sub_agents.find((a) => a.name === 'ci-checker');
+        expect(ci.tools).toContain('git');
+        expect(ci.tools).toContain('shell');
+        expect(ci.tools).toContain('code');
+    });
+    it('ci-checker has max_iterations of 3', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const ci = task.sub_agents.find((a) => a.name === 'ci-checker');
+        expect(ci.max_iterations).toBe(3);
+    });
+    it('ci-checker reads pull-request and code-changes', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const ci = task.sub_agents.find((a) => a.name === 'ci-checker');
+        expect(ci.reads).toContain('pull-request');
+        expect(ci.reads).toContain('code-changes');
+    });
+    it('ci-checker produces ci-report', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const ci = task.sub_agents.find((a) => a.name === 'ci-checker');
+        expect(ci.produces).toBe('ci-report');
+    });
+    it('get-pr-checks is in the git-read tool group', async () => {
+        const { expandToolNames } = await import('../tools/tool-groups.js');
+        const gitReadTools = expandToolNames(['git-read']);
+        expect(gitReadTools.has('get-pr-checks')).toBe(true);
+    });
+});
 describe('T-CREW-10-001: test-writer sub-agent has git tools', () => {
     let spec;
     beforeAll(async () => {
         const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
         spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
     });
-    it('test-writer has code, git, and shell tools', () => {
+    it('test-writer has code, git-read, git-commit, and shell tools (least privilege)', () => {
         const task = spec.persona.tasks['implement-story'];
         const tw = task.sub_agents.find((a) => a.name === 'test-writer');
         expect(tw).toBeDefined();
         expect(tw.tools).toContain('code');
-        expect(tw.tools).toContain('git');
+        expect(tw.tools).toContain('git-read');
+        expect(tw.tools).toContain('git-commit');
         expect(tw.tools).toContain('shell');
+        expect(tw.tools).not.toContain('git');
     });
 });
 describe('T-FR-05: quality-checker sub-agent configuration', () => {
@@ -517,12 +563,14 @@ describe('T-FR-05: quality-checker sub-agent configuration', () => {
         expect(qc).toBeDefined();
         expect(qc.skill).toBe('quality-check');
     });
-    it('quality-checker has shell, code, and git tools for running checks, fixing failures, and committing', () => {
+    it('quality-checker has shell, code, git-read, and git-commit tools (least privilege)', () => {
         const task = spec.persona.tasks['implement-story'];
         const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
         expect(qc.tools).toContain('shell');
         expect(qc.tools).toContain('code');
-        expect(qc.tools).toContain('git');
+        expect(qc.tools).toContain('git-read');
+        expect(qc.tools).toContain('git-commit');
+        expect(qc.tools).not.toContain('git');
     });
     it('quality-checker has max_iterations of 3', () => {
         const task = spec.persona.tasks['implement-story'];
@@ -541,7 +589,9 @@ describe('T-FR-05: quality-checker sub-agent configuration', () => {
         expect(qc.skill).toBe('quality-check');
         expect(qc.tools).toContain('shell');
         expect(qc.tools).toContain('code');
-        expect(qc.tools).toContain('git');
+        expect(qc.tools).toContain('git-read');
+        expect(qc.tools).toContain('git-commit');
+        expect(qc.tools).not.toContain('git');
         expect(qc.max_iterations).toBe(3);
     });
 });

package/dist/engine/composite.js

@@ -58,7 +58,7 @@ async function evaluateGate(gateExpression, subAgentOutput, provider, model) {
         };
     }
     catch {
-        return { pass: true, reason: 'Gate evaluation produced non-JSON output; defaulting to pass' };
+        return { pass: false, reason: 'Gate evaluation produced non-JSON output; treating as fail' };
     }
 }
 /**

package/dist/engine/composite.test.js

@@ -282,6 +282,96 @@ describe('T-01-004c: jump-back via on_fail/gate/max_loops', () => {
         const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
         expect(result.content).toBe('');
     });
+    it('treats malformed gate response as fail (CREW-10-004)', async () => {
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: 'This is not valid JSON at all',
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: 'some output',
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const task = makeTask({
+            sub_agents: [
+                { name: 'implementer', skill: 'feature-implementation', reads: [], produces: 'code' },
+                {
+                    name: 'reviewer',
+                    skill: 'code-review',
+                    reads: ['code'],
+                    produces: 'review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 1,
+                },
+            ],
+            published_artifact: 'review',
+        });
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('');
+    });
+    it('loops back on malformed gate with sufficient max_loops (CREW-10-004)', async () => {
+        let gateCallCount = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    gateCallCount++;
+                    if (gateCallCount < 2) {
+                        return Promise.resolve({
+                            text: 'NOT JSON',
+                            toolCalls: [],
+                            tokensIn: 5,
+                            tokensOut: 5,
+                        });
+                    }
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok now' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: 'some output',
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const task = makeTask({
+            sub_agents: [
+                { name: 'implementer', skill: 'feature-implementation', reads: [], produces: 'code' },
+                {
+                    name: 'reviewer',
+                    skill: 'code-review',
+                    reads: ['code'],
+                    produces: 'review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 2,
+                },
+            ],
+            published_artifact: 'review',
+        });
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).not.toBe('');
+        const implementerRuns = result.subAgentResults.filter((r) => r.name === 'implementer');
+        expect(implementerRuns.length).toBe(2);
+    });
 });
 describe('T-01-004d: checkpoint work products', () => {
     it('writes each sub-agent output to runs/{run_id}/work/', async () => {
@@ -349,7 +439,7 @@ describe('T-FR-04: test-writer sub-agent', () => {
                     skill: 'test-writing',
                     reads: ['code-changes', 'requirements'],
                     produces: 'test-files',
-                    tools: ['code', 'git', 'shell'],
+                    tools: ['code', 'git-read', 'git-commit', 'shell'],
                 },
             ],
             published_artifact: 'test-files',
@@ -401,7 +491,7 @@ describe('T-FR-04: test-writer sub-agent', () => {
             .content;
         expect(testWriterPrompt).toContain('code-changes');
     });
-    it('restricts tools to code, git, and shell groups', async () => {
+    it('restricts tools to code, git-read, git-commit, and shell', async () => {
         const noop = async () => ({});
         const tools = {
             'read-artifact': {
@@ -431,14 +521,7 @@ describe('T-FR-04: test-writer sub-agent', () => {
         const calls = provider.generateText.mock.calls;
         const testWriterCall = calls[1][0];
         const toolNames = Object.keys(testWriterCall.tools ?? {}).sort();
-        expect(toolNames).toEqual([
-            'git-branch',
-            'git-commit',
-            'git-diff',
-            'read-file',
-            'run-command',
-            'write-file',
-        ]);
+        expect(toolNames).toEqual(['git-commit', 'git-diff', 'read-file', 'run-command', 'write-file']);
     });
     it('produces test-files output and checkpoints it', async () => {
         const provider = sequentialProvider(['code changes', 'test file content']);
@@ -1588,8 +1671,8 @@ describe('T-FR-03: implementer sub-agent', () => {
 });
 describe('T-FR-07: end-to-end implement-story composite task', () => {
     /**
-     * Full 6-step sub-agent chain matching the engineer persona spec:
-     * planner -> implementer -> test-writer -> quality-checker -> self-reviewer -> pr-author
+     * Full 7-step sub-agent chain matching the engineer persona spec:
+     * planner -> implementer -> test-writer -> quality-checker -> self-reviewer -> pr-author -> ci-checker
      */
     function makeFullImplementStoryTask() {
         return {
@@ -1615,14 +1698,14 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
                     skill: 'test-writing',
                     reads: ['code-changes', 'requirements'],
                     produces: 'test-files',
-                    tools: ['code', 'git', 'shell'],
+                    tools: ['code', 'git-read', 'git-commit', 'shell'],
                 },
                 {
                     name: 'quality-checker',
                     skill: 'quality-check',
                     reads: ['code-changes', 'test-files'],
                     produces: 'quality-report',
-                    tools: ['shell', 'code', 'git'],
+                    tools: ['shell', 'code', 'git-read', 'git-commit'],
                     max_iterations: 3,
                 },
                 {
@@ -1641,8 +1724,16 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
                     produces: 'pull-request',
                     tools: ['git'],
                 },
+                {
+                    name: 'ci-checker',
+                    skill: 'ci-check',
+                    reads: ['pull-request', 'code-changes'],
+                    produces: 'ci-report',
+                    tools: ['git', 'shell', 'code'],
+                    max_iterations: 3,
+                },
             ],
-            published_artifact: 'pull-request',
+            published_artifact: 'ci-report',
             quality_gate: 'human-review',
         };
     }
@@ -1660,6 +1751,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
                     'test-writing',
                     'self-review',
                     'pr-authoring',
+                    'ci-check',
                 ],
                 perception: { per_task: {} },
                 tasks: {},
@@ -1679,6 +1771,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         'quality-check': 'Run lint, typecheck, tests. Fix failures iteratively.',
         'self-review': 'Review changes against design. Report blocking issues.',
         'pr-authoring': 'Create a GitHub PR with structured description.',
+        'ci-check': 'Poll CI checks. Fix failures if needed. Produce CI report.',
         'feature-implementation': 'Feature implementation skill.',
         'code-review': 'Code review skill.',
     };
@@ -1691,6 +1784,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
             'quality-checker',
             'self-reviewer',
             'pr-author',
+            'ci-checker',
         ];
         return {
             generateText: vi
@@ -1715,7 +1809,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
             }),
         };
     }
-    it('executes all 6 sub-agents in sequence', async () => {
+    it('executes all 7 sub-agents in sequence', async () => {
         const provider = gatePassingProvider({
             planner: '## Plan\nModify engine/composite.ts',
             implementer: 'Created branch, wrote code, committed',
@@ -1723,15 +1817,17 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
             'quality-checker': 'Lint: pass, Typecheck: pass, Tests: 14/14 pass',
             'self-reviewer': '## Verdict: PASS\nNo blocking issues.',
             'pr-author': 'Created PR #47: feat(CREW-03-011): end-to-end composite task',
+            'ci-checker': '# CI Check Report\n\n**Overall: PASS**',
         });
         const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
-        expect(result.subAgentResults).toHaveLength(6);
+        expect(result.subAgentResults).toHaveLength(7);
         expect(result.subAgentResults[0].name).toBe('planner');
         expect(result.subAgentResults[1].name).toBe('implementer');
         expect(result.subAgentResults[2].name).toBe('test-writer');
         expect(result.subAgentResults[3].name).toBe('quality-checker');
         expect(result.subAgentResults[4].name).toBe('self-reviewer');
         expect(result.subAgentResults[5].name).toBe('pr-author');
+        expect(result.subAgentResults[6].name).toBe('ci-checker');
     });
     it('shares working state between all sub-agents', async () => {
         const planOutput = '## Plan\n1. Modify composite.ts\n2. Add tests';
@@ -1758,34 +1854,35 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         expect(qualityPrompt).toContain(codeOutput);
         expect(qualityPrompt).toContain(testOutput);
     });
-    it('checkpoints all 6 intermediate work products', async () => {
+    it('checkpoints all 7 intermediate work products', async () => {
         const provider = gatePassingProvider({});
         const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
-        expect(result.checkpoints).toHaveLength(6);
+        expect(result.checkpoints).toHaveLength(7);
         expect(result.checkpoints[0].path).toContain('01-planner.md');
         expect(result.checkpoints[1].path).toContain('02-implementer.md');
         expect(result.checkpoints[2].path).toContain('03-test-writer.md');
         expect(result.checkpoints[3].path).toContain('04-quality-checker.md');
         expect(result.checkpoints[4].path).toContain('05-self-reviewer.md');
         expect(result.checkpoints[5].path).toContain('06-pr-author.md');
+        expect(result.checkpoints[6].path).toContain('07-ci-checker.md');
         for (const cp of result.checkpoints) {
             const content = await readFile(cp.path, 'utf-8');
             expect(content).toBeTruthy();
         }
     });
-    it('final output is from the PR author sub-agent', async () => {
-        const prOutput = 'Created PR #47: feat(CREW-03-011): end-to-end composite task wiring';
+    it('final output is from the ci-checker sub-agent', async () => {
+        const ciOutput = '# CI Check Report\n\n**Overall: PASS**\n\nAll checks passed.';
         const provider = gatePassingProvider({
-            'pr-author': prOutput,
+            'ci-checker': ciOutput,
         });
         const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
-        expect(result.content).toBe(prOutput);
+        expect(result.content).toBe(ciOutput);
     });
-    it('accumulates tokens across all 6 sub-agents', async () => {
+    it('accumulates tokens across all 7 sub-agents', async () => {
         const provider = gatePassingProvider({});
         const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
-        expect(result.tokensIn).toBe(600);
-        expect(result.tokensOut).toBe(300);
+        expect(result.tokensIn).toBe(700);
+        expect(result.tokensOut).toBe(350);
     });
     it('self-reviewer gate failure loops back to implementer', async () => {
         let subAgentIdx = 0;
@@ -1821,7 +1918,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         expect(names[3]).toBe('quality-checker');
         expect(names[4]).toBe('self-reviewer');
         expect(names[5]).toBe('implementer');
-        expect(names[names.length - 1]).toBe('pr-author');
+        expect(names[names.length - 1]).toBe('ci-checker');
         expect(result.content).not.toBe('');
     });
     it('provides assembled context to planner sub-agent', async () => {
@@ -1880,6 +1977,12 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
             'git-push': { name: 'git-push', description: 'push', parameters: {}, execute: noop },
             'git-diff': { name: 'git-diff', description: 'diff', parameters: {}, execute: noop },
             'git-log': { name: 'git-log', description: 'log', parameters: {}, execute: noop },
+            'get-pr-checks': {
+                name: 'get-pr-checks',
+                description: 'checks',
+                parameters: {},
+                execute: noop,
+            },
             'create-pr': { name: 'create-pr', description: 'pr', parameters: {}, execute: noop },
             'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
         };
@@ -1891,6 +1994,7 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         const implementerTools = Object.keys(calls[1][0].tools ?? {}).sort();
         expect(implementerTools).toEqual([
             'create-pr',
+            'get-pr-checks',
             'git-branch',
             'git-commit',
             'git-diff',
@@ -1904,12 +2008,10 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         ]);
         const testWriterTools = Object.keys(calls[2][0].tools ?? {}).sort();
         expect(testWriterTools).toEqual([
-            'create-pr',
-            'git-branch',
+            'get-pr-checks',
             'git-commit',
             'git-diff',
             'git-log',
-            'git-push',
             'list-directory',
             'read-file',
             'run-command',
@@ -1918,12 +2020,10 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         ]);
         const qualityCheckerTools = Object.keys(calls[3][0].tools ?? {}).sort();
         expect(qualityCheckerTools).toEqual([
-            'create-pr',
-            'git-branch',
+            'get-pr-checks',
             'git-commit',
             'git-diff',
             'git-log',
-            'git-push',
             'list-directory',
             'read-file',
             'run-command',
@@ -1937,11 +2037,31 @@ describe('T-FR-07: end-to-end implement-story composite task', () => {
         const prAuthorTools = Object.keys(calls[prAuthorIdx][0].tools ?? {}).sort();
         expect(prAuthorTools).toEqual([
             'create-pr',
+            'get-pr-checks',
             'git-branch',
             'git-commit',
             'git-diff',
             'git-log',
             'git-push',
         ]);
+        const ciCheckerIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: ci-report');
+        });
+        const ciCheckerTools = Object.keys(calls[ciCheckerIdx][0].tools ?? {}).sort();
+        expect(ciCheckerTools).toEqual([
+            'create-pr',
+            'get-pr-checks',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
     });
 });

package/dist/tools/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,WAAW,CA0T7E"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,WAAW,CAiW7E"}

package/dist/tools/registry.js

@@ -7,7 +7,7 @@
  * so the LLM only needs to provide the operation-specific parameters.
  */
 import { readFileFromRepo, writeFileToRepo, listDirectory, searchCodebase, } from '@helmiq/crew-code';
-import { gitBranch, gitCommit, gitPush, gitDiff, gitLog, createPr } from '@helmiq/crew-git';
+import { gitBranch, gitCommit, gitPush, gitDiff, gitLog, createPr, getPrChecks, } from '@helmiq/crew-git';
 import { runCommand, createAllowlist } from '@helmiq/crew-shell';
 export function createToolRegistry(options) {
     const registry = {
@@ -162,6 +162,39 @@ export function createToolRegistry(options) {
                 return gitLog({ maxCount, path }, ctx.targetRepoPath);
             },
         },
+        'get-pr-checks': {
+            name: 'get-pr-checks',
+            description: 'Poll GitHub check runs for a commit or branch. Waits for all checks to complete (up to timeout) and returns pass/fail status.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    ref: {
+                        type: 'string',
+                        description: 'Git ref to check (branch name, commit SHA, or PR head ref)',
+                    },
+                    timeoutSeconds: {
+                        type: 'number',
+                        description: 'Maximum seconds to wait for checks to complete (default: 120)',
+                    },
+                    intervalSeconds: {
+                        type: 'number',
+                        description: 'Seconds between poll attempts (default: 15)',
+                    },
+                },
+                required: ['ref'],
+            },
+            execute: async (params, ctx) => {
+                const { ref, timeoutSeconds, intervalSeconds } = params;
+                const [owner, repo] = ctx.project.source.repo.replace('github:', '').split('/');
+                return getPrChecks({
+                    owner: owner,
+                    repo: repo,
+                    ref,
+                    timeoutSeconds,
+                    intervalSeconds,
+                });
+            },
+        },
         'create-pr': {
             name: 'create-pr',
             description: 'Create a GitHub pull request. The branch must be pushed to the remote first using git-push; creation will fail if the branch does not exist on the remote.',

package/dist/tools/registry.test.js

@@ -21,6 +21,7 @@ describe('createToolRegistry', () => {
         const names = Object.keys(registry).sort();
         expect(names).toEqual([
             'create-pr',
+            'get-pr-checks',
             'git-branch',
             'git-commit',
             'git-diff',

package/dist/tools/tool-groups.js

@@ -12,7 +12,7 @@
  */
 const CODE_READ = ['read-file', 'list-directory', 'search-codebase'];
 const CODE_WRITE = ['write-file'];
-const GIT_READ = ['git-diff', 'git-log'];
+const GIT_READ = ['git-diff', 'git-log', 'get-pr-checks'];
 const GIT_WRITE = ['git-branch', 'git-commit', 'git-push', 'create-pr'];
 const GIT_ALL = [...GIT_READ, ...GIT_WRITE];
 export const TOOL_GROUPS = {

package/dist/tools/tool-groups.test.js

@@ -13,7 +13,7 @@ describe('tool-groups', () => {
             expect(TOOL_GROUPS['code']).toEqual(expect.arrayContaining(['read-file', 'write-file', 'list-directory', 'search-codebase']));
         });
         it('defines git-read group with read-only git tools', () => {
-            expect(TOOL_GROUPS['git-read']).toEqual(expect.arrayContaining(['git-diff', 'git-log']));
+            expect(TOOL_GROUPS['git-read']).toEqual(expect.arrayContaining(['git-diff', 'git-log', 'get-pr-checks']));
             expect(TOOL_GROUPS['git-read']).not.toContain('git-branch');
             expect(TOOL_GROUPS['git-read']).not.toContain('git-commit');
         });
@@ -29,6 +29,7 @@ describe('tool-groups', () => {
                 'git-push',
                 'git-diff',
                 'git-log',
+                'get-pr-checks',
                 'create-pr',
             ]));
         });
@@ -54,7 +55,7 @@ describe('tool-groups', () => {
         });
         it('expands git-read to read-only git tools', () => {
             const result = expandToolNames(new Set(['git-read']));
-            expect(result).toEqual(new Set(['git-diff', 'git-log']));
+            expect(result).toEqual(new Set(['git-diff', 'git-log', 'get-pr-checks']));
         });
         it('expands git-write to mutating git tools', () => {
             const result = expandToolNames(new Set(['git-write']));
@@ -70,6 +71,7 @@ describe('tool-groups', () => {
             expect(result).toContain('read-file');
             expect(result).toContain('git-branch');
             expect(result).toContain('git-diff');
+            expect(result).toContain('get-pr-checks');
             expect(result).toContain('run-command');
         });
         it('handles mix of group names and individual names', () => {
@@ -97,6 +99,7 @@ describe('tool-groups', () => {
                 'git-push',
                 'git-diff',
                 'git-log',
+                'get-pr-checks',
                 'create-pr',
                 'run-command',
             ]));
@@ -112,6 +115,7 @@ describe('tool-groups', () => {
             const denied = expandToolNames(['write-code', 'git-write']);
             expect(permitted).toContain('read-file');
             expect(permitted).toContain('git-diff');
+            expect(permitted).toContain('get-pr-checks');
             expect(permitted).toContain('run-command');
             expect(permitted).not.toContain('write-file');
             expect(permitted).not.toContain('git-branch');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helmiq/crew",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Artifact-centric autonomous delivery runtime",
   "type": "module",
   "license": "MIT",
@@ -19,7 +19,11 @@
   "engines": {
     "node": ">=20.9.0"
   },
+  "bin": {
+    "crew": "./bin/crew.cjs"
+  },
   "files": [
+    "bin",
     "dist",
     "defaults"
   ],
@@ -35,9 +39,9 @@
     "simple-git": "^3.33.0",
     "yaml": "^2.8.3",
     "zod": "^4.3.6",
-    "@helmiq/crew-code": "0.1.0",
-    "@helmiq/crew-git": "0.1.0",
-    "@helmiq/crew-shell": "0.1.0"
+    "@helmiq/crew-code": "0.1.1",
+    "@helmiq/crew-git": "0.1.1",
+    "@helmiq/crew-shell": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",