crewly 1.20.192 → 1.20.194

package/frontend/dist/index.html

@@ -7,8 +7,8 @@
     <meta name="color-scheme" content="dark" />
     <!-- Nunito font is self-hosted via @fontsource/nunito (imported in main.tsx) -->
     <title>Crewly AI Studio</title>
-    <script type="module" crossorigin src="/assets/index-5b7af029.js"></script>
-    <link rel="stylesheet" href="/assets/index-fc715ec3.css">
+    <script type="module" crossorigin src="/assets/index-800118ca.js"></script>
+    <link rel="stylesheet" href="/assets/index-5e967795.css">
   </head>
   <body class="bg-background-dark font-display text-text-primary-dark">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewly",
-  "version": "1.20.192",
+  "version": "1.20.194",
   "type": "module",
   "description": "Multi-agent orchestration platform for AI coding teams — coordinates Claude Code, Gemini CLI, and Codex agents with a real-time web dashboard",
   "workspaces": [

package/packages/crewly-agent/src/runtime/tool-registry.test.ts

@@ -1363,6 +1363,19 @@ describe('Tool Registry', () => {
       );
     });
 
+    it('passes evidence through on the done auto-complete (#873)', async () => {
+      mockClient.post.mockResolvedValue({ success: true, data: { acknowledged: true }, status: 200 });
+      mockClient.get.mockResolvedValueOnce({ success: true, data: { workItems: [{ id: 'wi-running-2' }] }, status: 200 });
+      const evidence = [{ type: 'blocked', step: 'npm test', reason: 'db down' }];
+
+      await (tools.report_status as any).execute({ status: 'done', summary: 'Could not finish', evidence });
+
+      expect(mockClient.post).toHaveBeenCalledWith(
+        '/task-pool/complete/wi-running-2',
+        { agentId: 'crewly-orc', result: { summary: 'Could not finish', evidence } },
+      );
+    });
+
     it('should not auto-complete tasks when status is in_progress', async () => {
       mockClient.post.mockResolvedValue({ success: true, data: { acknowledged: true }, status: 200 });
 
@@ -1916,6 +1929,38 @@ describe('Tool Registry', () => {
       );
     });
 
+    it('sends evidence under result.evidence (#873)', async () => {
+      mockClient.post.mockResolvedValue({ success: true, data: { completed: true }, status: 200 });
+      mockClient.get.mockResolvedValue({ success: true, data: [], status: 200 });
+      const evidence = [
+        { type: 'artifact', path: '/proj/report.md' },
+        { type: 'command', command: 'npm test', exitCode: 0, outputTail: '9 passed' },
+      ];
+
+      await (tools.complete_task as any).execute({
+        workItemId: 'wi-ev-1',
+        sessionName: 'agent-quinn',
+        summary: 'Report written',
+        evidence,
+      });
+
+      expect(mockClient.post).toHaveBeenCalledWith(
+        '/task-pool/complete/wi-ev-1',
+        { agentId: 'agent-quinn', result: { summary: 'Report written', evidence } },
+      );
+    });
+
+    it('complete_task schema accepts the three evidence types and rejects a command without exitCode', () => {
+      const schema = (tools.complete_task as any).inputSchema;
+      const base = { workItemId: 'w', sessionName: 's', summary: 'x' };
+      expect(schema.safeParse({ ...base, evidence: [
+        { type: 'artifact', path: '/a' },
+        { type: 'command', command: 'ls', exitCode: 0 },
+        { type: 'blocked', step: 'deploy', reason: 'no creds' },
+      ] }).success).toBe(true);
+      expect(schema.safeParse({ ...base, evidence: [{ type: 'command', command: 'ls' }] }).success).toBe(false);
+    });
+
     it('should still complete task even if check cleanup fails', async () => {
       mockClient.post.mockResolvedValue({ success: true, data: { completed: true }, status: 200 });
       mockClient.get.mockRejectedValue(new Error('Network error'));

package/packages/crewly-agent/src/runtime/tool-registry.ts

@@ -18,6 +18,39 @@ import type { ToolDefinition, ToolCallbacks, ToolSensitivity, AuditEntry, Approv
 import { KEY_EXTRACTION_BLOCKED_COMMANDS, PromptGuardService } from './prompt-guard.service.js';
 import { EnvIsolationService } from './env-isolation.service.js';
 import { OutputFilterService } from './output-filter.service.js';
+
+/**
+ * Completion evidence (#873): "done" needs evidence. Mirrors
+ * `CompletionEvidence` in backend/src/types/v2/completion-evidence.types.ts;
+ * the server validates it again and checks artifacts exist / exit codes are 0.
+ */
+const completionEvidenceSchema = z.array(z.discriminatedUnion('type', [
+  z.object({ type: z.literal('artifact'), path: z.string().min(1).describe('Existing file path (absolute or project-relative) or https URL') }),
+  z.object({
+    type: z.literal('command'),
+    command: z.string().min(1),
+    exitCode: z.number().int().describe('Exit code; must be 0 to count as evidence of done'),
+    outputTail: z.string().optional().describe('Last lines of the output'),
+  }),
+  z.object({ type: z.literal('blocked'), step: z.string().min(1), reason: z.string().min(1) }),
+])).describe(
+  'Evidence for "done": artifacts that exist, commands with exit codes, or {type:"blocked",step,reason} ' +
+  'if you could not finish (the WorkItem is then recorded as blocked, not done).',
+);
+
+/** One completion evidence entry, as accepted by {@link completionEvidenceSchema}. */
+type CompletionEvidenceInput = z.infer<typeof completionEvidenceSchema>;
+
+/**
+ * Build the canonical `/task-pool/complete` result object.
+ *
+ * @param summary - What was produced
+ * @param evidence - Optional evidence entries (omitted when empty)
+ * @returns `{summary}` plus `evidence` when given
+ */
+function completionResult(summary: string, evidence: CompletionEvidenceInput | undefined): Record<string, unknown> {
+  return { summary, ...(evidence && evidence.length > 0 ? { evidence } : {}) };
+}
 import { createWebSearchTool } from './web-search.tool.js';
 import { createComputerTool } from './computer.tool.js';
 import { createDesktopTaskTool } from './desktop-task.tool.js';
@@ -1246,13 +1279,14 @@ export function createTools(client: CrewlyApiClient, sessionName: string, projec
     },
 
     complete_task: {
-      description: 'Mark a WorkItem as complete. Also cancels any scheduled checks targeting the completing agent session.',
+      description: 'Mark a WorkItem as complete, with evidence (artifacts that exist, commands with exit codes) or a blocked step. Also cancels any scheduled checks targeting the completing agent session.',
       inputSchema: z.object({
         workItemId: z.string().describe('WorkItem id to complete'),
         sessionName: z.string().describe('Agent session that completed it'),
         summary: z.string().describe('Completion summary'),
+        evidence: completionEvidenceSchema.optional(),
       }),
-      execute: async ({ workItemId, sessionName: agent, summary }) => {
+      execute: async ({ workItemId, sessionName: agent, summary, evidence }) => {
         // V3-only as of spec 2026-05-06-task-management-v1-deprecation.md.
         // Replaces v1 `/task-management/complete`. Note: the legacy
         // `absoluteTaskPath` parameter is removed; callers must now pass
@@ -1268,7 +1302,7 @@ export function createTools(client: CrewlyApiClient, sessionName: string, projec
         //   - tool-registry.ts §report_status auto-complete path (below)
         const result = await client.post(`/task-pool/complete/${workItemId}`, {
           agentId: agent,
-          result: { summary },
+          result: completionResult(summary as string, evidence as CompletionEvidenceInput | undefined),
         });
 
         // Auto-cancel scheduled checks targeting the completing agent
@@ -1673,8 +1707,9 @@ export function createTools(client: CrewlyApiClient, sessionName: string, projec
       inputSchema: z.object({
         status: z.enum(['in_progress', 'done', 'blocked', 'error']).describe('Current status'),
         summary: z.string().describe('Brief status summary'),
+        evidence: completionEvidenceSchema.optional().describe('Evidence when status is done (#873)'),
       }),
-      execute: async ({ status, summary }) => {
+      execute: async ({ status, summary, evidence }) => {
         // Build status message matching the bash report-status format
         const statusUpper = (status as string).toUpperCase();
         const message = `[${statusUpper}] Agent ${sessionName}: ${summary}`;
@@ -1714,7 +1749,7 @@ export function createTools(client: CrewlyApiClient, sessionName: string, projec
               await client
                 .post(`/task-pool/complete/${wiId}`, {
                   agentId: sessionName,
-                  result: { summary },
+                  result: completionResult(summary as string, evidence as CompletionEvidenceInput | undefined),
                 })
                 .catch(() => {});
             }

package/packages/crewly-agent/src/test/isolated-home.test.ts

@@ -0,0 +1,24 @@
+/**
+ * Guard for vitest.setup.ts: tests run against a temp home, never the real one.
+ */
+import * as os from 'node:os';
+import { homedir } from 'node:os';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { CLOUD_CONFIG_PATH } from '../runtime/cloud-config.js';
+
+describe('vitest setup — isolated home', () => {
+  const realHome = os.userInfo().homedir;
+
+  it('points os.homedir() (namespace and named import), HOME and CREWLY_HOME at a temp home', () => {
+    expect(os.homedir()).not.toBe(realHome);
+    expect(homedir()).toBe(os.homedir());
+    expect(process.env.HOME).toBe(os.homedir());
+    expect(process.env.CREWLY_HOME).toBe(path.join(os.homedir(), '.crewly'));
+  });
+
+  it('resolves the cloud config path (computed at import) inside the temp home', () => {
+    expect(CLOUD_CONFIG_PATH.startsWith(os.homedir() + path.sep)).toBe(true);
+    expect(CLOUD_CONFIG_PATH.startsWith(path.join(realHome, '.crewly'))).toBe(false);
+  });
+});