@a5c-ai/krate 5.0.1-staging.00fa5317c

package/tests/agent-trigger-routes.test.js

@@ -0,0 +1,190 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeWebhookEvent } from '../src/index.js';
+
+describe('normalizeWebhookEvent', () => {
+  // 1. GitHub workflow_run failure -> type: 'ci-failure'
+  it('normalizes GitHub workflow_run failure to ci-failure', () => {
+    const body = {
+      action: 'completed',
+      workflow_run: { conclusion: 'failure', name: 'CI Build', head_branch: 'feature-x' },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'alice' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'ci-failure');
+    assert.equal(event.source.kind, 'Pipeline');
+    assert.equal(event.source.name, 'CI Build');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.ref, 'feature-x');
+    assert.equal(event.actor, 'alice');
+    assert.equal(event.payload, body);
+  });
+
+  // 2. GitHub PR opened -> type: 'pr-opened'
+  it('normalizes GitHub PR opened to pr-opened', () => {
+    const body = {
+      action: 'opened',
+      pull_request: { number: 42, head: { ref: 'feat/login' } },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'bob' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'pr-opened');
+    assert.equal(event.source.kind, 'PullRequest');
+    assert.equal(event.source.name, '42');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.ref, 'feat/login');
+    assert.equal(event.actor, 'bob');
+    assert.equal(event.payload, body);
+  });
+
+  // 3. GitHub issue comment -> type: 'comment' with kind 'Issue'
+  it('normalizes GitHub issue comment to comment with kind Issue', () => {
+    const body = {
+      action: 'created',
+      comment: { body: 'Looks good!', user: { login: 'reviewer' } },
+      issue: { number: 10 },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'reviewer' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'comment');
+    assert.equal(event.source.kind, 'Issue');
+    assert.equal(event.source.name, '10');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.actor, 'reviewer');
+    assert.deepEqual(event.payload, { body: 'Looks good!' });
+  });
+
+  // 4. GitHub PR comment -> type: 'comment' with kind 'PullRequest'
+  it('normalizes GitHub PR comment to comment with kind PullRequest', () => {
+    const body = {
+      action: 'created',
+      comment: { body: 'LGTM', user: { login: 'reviewer' } },
+      issue: { number: 7, pull_request: { url: 'https://api.github.com/repos/acme/app/pulls/7' } },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'reviewer' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'comment');
+    assert.equal(event.source.kind, 'PullRequest');
+    assert.equal(event.source.name, '7');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.actor, 'reviewer');
+    assert.deepEqual(event.payload, { body: 'LGTM' });
+  });
+
+  // 5. GitHub label added -> type: 'label-added'
+  it('normalizes GitHub label added to label-added', () => {
+    const body = {
+      action: 'labeled',
+      label: { name: 'bug' },
+      issue: { number: 15 },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'triager' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'label-added');
+    assert.equal(event.source.kind, 'Issue');
+    assert.equal(event.source.name, '15');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.actor, 'triager');
+    assert.deepEqual(event.payload, { label: 'bug' });
+  });
+
+  // 6. GitHub push -> type: 'push'
+  it('normalizes GitHub push to push', () => {
+    const body = {
+      ref: 'refs/heads/main',
+      commits: [{ id: 'abc123', message: 'fix typo' }],
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'dev' },
+      pusher: { name: 'dev' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'push');
+    assert.equal(event.source.kind, 'Repository');
+    assert.equal(event.source.name, 'acme/app');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.ref, 'main');
+    assert.equal(event.actor, 'dev');
+    assert.equal(event.payload, body);
+  });
+
+  // 7. Unknown payload -> type: 'webhook' (fallback)
+  it('returns webhook fallback for unknown payload', () => {
+    const body = {
+      action: 'some-unknown-action',
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'bot' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'webhook');
+    assert.equal(event.source.kind, 'WebhookDelivery');
+    assert.equal(event.source.name, 'unknown');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.actor, 'bot');
+    assert.equal(event.payload, body);
+  });
+
+  // 8. Empty/minimal payload -> doesn't crash
+  it('handles empty payload without crashing', () => {
+    const event = normalizeWebhookEvent({}, 'acme');
+
+    assert.equal(event.type, 'webhook');
+    assert.equal(event.source.kind, 'WebhookDelivery');
+    assert.equal(event.source.name, 'unknown');
+    assert.equal(event.repository, '');
+    assert.equal(event.actor, 'system');
+    assert.equal(event.ref, 'main');
+  });
+
+  it('handles minimal payload with only action without crashing', () => {
+    const event = normalizeWebhookEvent({ action: 'opened' }, 'acme');
+
+    assert.equal(event.type, 'webhook');
+    assert.equal(event.source.kind, 'WebhookDelivery');
+  });
+
+  // Additional: label on PR (not issue)
+  it('normalizes label on PR with kind PullRequest', () => {
+    const body = {
+      action: 'labeled',
+      label: { name: 'ready-to-merge' },
+      pull_request: { number: 99 },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'lead' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'label-added');
+    assert.equal(event.source.kind, 'PullRequest');
+    assert.equal(event.source.name, '99');
+    assert.deepEqual(event.payload, { label: 'ready-to-merge' });
+  });
+
+  // Additional: issue opened (not PR)
+  it('normalizes issue opened to issue-created', () => {
+    const body = {
+      action: 'opened',
+      issue: { number: 33 },
+      repository: { full_name: 'acme/app' },
+      sender: { login: 'reporter' }
+    };
+    const event = normalizeWebhookEvent(body, 'acme');
+
+    assert.equal(event.type, 'issue-created');
+    assert.equal(event.source.kind, 'Issue');
+    assert.equal(event.source.name, '33');
+    assert.equal(event.repository, 'acme/app');
+    assert.equal(event.actor, 'reporter');
+  });
+});

package/tests/agent-trigger-sources.test.js

@@ -0,0 +1,245 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  validateCronExpression,
+  calculateNextRun,
+  validateWebhookTrigger,
+  validateCommentTrigger,
+  validateLabelTrigger,
+  getTriggerSourceType,
+  validateTriggerRule,
+  createResource,
+} from '../src/index.js';
+
+// ── Cron validation ──────────────────────────────────────────────────────────
+
+test('validateCronExpression: accepts valid 5-field cron expression', () => {
+  const result = validateCronExpression('*/5 * * * *');
+  assert.equal(result.valid, true);
+  assert.equal(result.error, undefined);
+});
+
+test('validateCronExpression: accepts complex valid cron (fixed values + ranges)', () => {
+  const result = validateCronExpression('0 9-17 * * 1-5');
+  assert.equal(result.valid, true);
+});
+
+test('validateCronExpression: rejects invalid cron string (non-cron words)', () => {
+  const result = validateCronExpression('not a cron');
+  assert.equal(result.valid, false);
+  assert.ok(typeof result.error === 'string' && result.error.length > 0, 'Should have an error message');
+});
+
+test('validateCronExpression: rejects empty string', () => {
+  const result = validateCronExpression('');
+  assert.equal(result.valid, false);
+  assert.ok(result.error, 'Should have an error message');
+});
+
+test('validateCronExpression: rejects fewer than 5 fields', () => {
+  const result = validateCronExpression('* * * *');
+  assert.equal(result.valid, false);
+  assert.ok(result.error.includes('5'), 'Error should mention 5-field requirement');
+});
+
+test('validateCronExpression: rejects more than 5 fields', () => {
+  const result = validateCronExpression('* * * * * *');
+  assert.equal(result.valid, false);
+  assert.ok(result.error.includes('5'), 'Error should mention 5-field requirement');
+});
+
+// ── calculateNextRun ─────────────────────────────────────────────────────────
+
+test('calculateNextRun: returns a future Date for a valid cron expression', () => {
+  const fromDate = new Date('2024-01-01T00:00:00Z');
+  const next = calculateNextRun('*/5 * * * *', fromDate);
+  assert.ok(next instanceof Date, 'Should return a Date');
+  assert.ok(next > fromDate, 'Returned date should be in the future relative to fromDate');
+});
+
+test('calculateNextRun: uses current date when fromDate is omitted', () => {
+  const before = new Date();
+  const next = calculateNextRun('0 0 * * *');
+  assert.ok(next instanceof Date, 'Should return a Date');
+  assert.ok(next > before, 'Returned date should be after invocation time');
+});
+
+test('calculateNextRun: returns null for invalid cron expression', () => {
+  const result = calculateNextRun('not-a-cron');
+  assert.equal(result, null);
+});
+
+// ── validateWebhookTrigger ───────────────────────────────────────────────────
+
+test('validateWebhookTrigger: accepts valid webhook config with url and secretRef', () => {
+  const config = { url: 'https://example.com/webhook', secretRef: 'my-webhook-secret' };
+  const result = validateWebhookTrigger(config);
+  assert.equal(result.valid, true);
+  assert.equal(result.error, undefined);
+});
+
+test('validateWebhookTrigger: rejects config missing url', () => {
+  const config = { secretRef: 'my-webhook-secret' };
+  const result = validateWebhookTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error.toLowerCase().includes('url'), 'Error should mention missing url');
+});
+
+test('validateWebhookTrigger: rejects config with non-http url scheme', () => {
+  const config = { url: 'ftp://example.com/webhook', secretRef: 'my-webhook-secret' };
+  const result = validateWebhookTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error, 'Should have an error message');
+});
+
+test('validateWebhookTrigger: accepts webhook config without secretRef (optional)', () => {
+  const config = { url: 'https://example.com/webhook' };
+  const result = validateWebhookTrigger(config);
+  assert.equal(result.valid, true);
+});
+
+// ── validateCommentTrigger ───────────────────────────────────────────────────
+
+test('validateCommentTrigger: accepts valid comment trigger with pattern and repos', () => {
+  const config = { pattern: '/run-agent', repos: ['myorg/myrepo'] };
+  const result = validateCommentTrigger(config);
+  assert.equal(result.valid, true);
+  assert.equal(result.error, undefined);
+});
+
+test('validateCommentTrigger: accepts comment trigger without repos (global scope)', () => {
+  const config = { pattern: '/deploy' };
+  const result = validateCommentTrigger(config);
+  assert.equal(result.valid, true);
+});
+
+test('validateCommentTrigger: rejects empty pattern', () => {
+  const config = { pattern: '', repos: ['myorg/myrepo'] };
+  const result = validateCommentTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error.toLowerCase().includes('pattern'), 'Error should mention pattern');
+});
+
+test('validateCommentTrigger: rejects missing pattern field', () => {
+  const config = { repos: ['myorg/myrepo'] };
+  const result = validateCommentTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error, 'Should have an error message');
+});
+
+// ── validateLabelTrigger ─────────────────────────────────────────────────────
+
+test('validateLabelTrigger: accepts valid label config with labels array and action', () => {
+  const config = { labels: ['bug', 'urgent'], action: 'labeled' };
+  const result = validateLabelTrigger(config);
+  assert.equal(result.valid, true);
+  assert.equal(result.error, undefined);
+});
+
+test('validateLabelTrigger: accepts label config with action "unlabeled"', () => {
+  const config = { labels: ['wontfix'], action: 'unlabeled' };
+  const result = validateLabelTrigger(config);
+  assert.equal(result.valid, true);
+});
+
+test('validateLabelTrigger: rejects empty labels array', () => {
+  const config = { labels: [], action: 'labeled' };
+  const result = validateLabelTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error.toLowerCase().includes('label'), 'Error should mention labels');
+});
+
+test('validateLabelTrigger: rejects missing labels field', () => {
+  const config = { action: 'labeled' };
+  const result = validateLabelTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error, 'Should have an error message');
+});
+
+test('validateLabelTrigger: rejects invalid action value', () => {
+  const config = { labels: ['bug'], action: 'deleted' };
+  const result = validateLabelTrigger(config);
+  assert.equal(result.valid, false);
+  assert.ok(result.error.toLowerCase().includes('action'), 'Error should mention action');
+});
+
+// ── getTriggerSourceType ─────────────────────────────────────────────────────
+
+test('getTriggerSourceType: returns "cron" for rule with cronExpression', () => {
+  const rule = { spec: { cronExpression: '*/5 * * * *' } };
+  assert.equal(getTriggerSourceType(rule), 'cron');
+});
+
+test('getTriggerSourceType: returns "webhook" for rule with webhookTrigger', () => {
+  const rule = { spec: { webhookTrigger: { url: 'https://example.com/hook' } } };
+  assert.equal(getTriggerSourceType(rule), 'webhook');
+});
+
+test('getTriggerSourceType: returns "comment" for rule with commentTrigger', () => {
+  const rule = { spec: { commentTrigger: { pattern: '/run' } } };
+  assert.equal(getTriggerSourceType(rule), 'comment');
+});
+
+test('getTriggerSourceType: returns "label" for rule with labelTrigger', () => {
+  const rule = { spec: { labelTrigger: { labels: ['bug'], action: 'labeled' } } };
+  assert.equal(getTriggerSourceType(rule), 'label');
+});
+
+test('getTriggerSourceType: returns "event" for rule with only sources array', () => {
+  const rule = { spec: { sources: ['ci-failure'] } };
+  assert.equal(getTriggerSourceType(rule), 'event');
+});
+
+test('getTriggerSourceType: returns "unknown" for rule with no recognized source spec', () => {
+  const rule = { spec: {} };
+  assert.equal(getTriggerSourceType(rule), 'unknown');
+});
+
+// ── validateTriggerRule with cron source ─────────────────────────────────────
+
+test('validateTriggerRule: rule with valid cron source passes validation', () => {
+  const rule = createResource(
+    'AgentTriggerRule',
+    { name: 'cron-rule', namespace: 'krate-org-default' },
+    {
+      organizationRef: 'default',
+      cronExpression: '0 */6 * * *',
+      agentStack: 'maintenance-stack',
+      taskKind: 'maintenance',
+    }
+  );
+  const result = validateTriggerRule(rule);
+  assert.equal(result.valid, true);
+  assert.equal(result.errors.length, 0);
+});
+
+test('validateTriggerRule: rule with invalid cron expression fails validation', () => {
+  const rule = createResource(
+    'AgentTriggerRule',
+    { name: 'bad-cron-rule', namespace: 'krate-org-default' },
+    {
+      organizationRef: 'default',
+      cronExpression: 'every five minutes',
+      agentStack: 'maintenance-stack',
+      taskKind: 'maintenance',
+    }
+  );
+  const result = validateTriggerRule(rule);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.length > 0, 'Should have validation errors');
+});
+
+test('validateTriggerRule: rule with webhook source passes validation', () => {
+  const rule = createResource(
+    'AgentTriggerRule',
+    { name: 'webhook-rule', namespace: 'krate-org-default' },
+    {
+      organizationRef: 'default',
+      webhookTrigger: { url: 'https://example.com/hook', secretRef: 'hook-secret' },
+      agentStack: 'webhook-stack',
+      taskKind: 'on-demand',
+    }
+  );
+  const result = validateTriggerRule(rule);
+  assert.equal(result.valid, true);
+});

package/tests/agent-workspace-controller.test.js

@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentWorkspaceController, createResource } from '../src/index.js';
+
+function makeWorkspace(name, repository, runRef, phase = 'InUse', extra = {}) {
+  const workspace = createResource('KrateWorkspace', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    repository,
+    volumeSpec: extra.volumeSpec || { storageClassName: 'standard', capacity: '10Gi', accessModes: ['ReadWriteOnce'] },
+    branch: extra.branch || 'main',
+    pvcName: extra.pvcName || `krate-ws-${name}`,
+  });
+  workspace.status = { phase, createdAt: new Date().toISOString(), runRef: runRef || undefined, volumeStatus: 'Bound', ...extra.status };
+  return workspace;
+}
+
+function makeRuntime(name, workspaceRef, status = 'provisioning') {
+  const runtime = createResource('KrateWorkspaceRuntime', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    workspaceRef,
+    status
+  });
+  runtime.status = { phase: 'Provisioning', createdAt: new Date().toISOString() };
+  return runtime;
+}
+
+test('provisionWorkspace creates KrateWorkspace + KrateWorkspaceRuntime', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.provisionWorkspace({
+    repository: 'my-repo',
+    ref: 'abc123',
+    branch: 'feature-1',
+    dispatchRun: 'run-1',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.workspace, 'Should return a workspace resource');
+  assert.equal(result.workspace.kind, 'KrateWorkspace');
+  assert.equal(result.workspace.spec.repository, 'my-repo');
+  assert.equal(result.workspace.status.runRef, 'run-1');
+  assert.equal(result.workspace.status.phase, 'InUse');
+  assert.ok(result.pvcManifest, 'Should return a PVC manifest');
+
+  assert.ok(result.runtime, 'Should return a runtime resource');
+  assert.equal(result.runtime.kind, 'KrateWorkspaceRuntime');
+  assert.equal(result.runtime.spec.workspaceRef, result.workspace.metadata.name);
+  assert.equal(result.runtime.spec.status, 'provisioning');
+  assert.equal(result.runtime.status.phase, 'Provisioning');
+});
+
+test('archiveWorkspace sets phase=Archived', () => {
+  const controller = createAgentWorkspaceController();
+  const existing = makeWorkspace('ws-1', 'my-repo', 'run-1', 'InUse');
+  const result = controller.archiveWorkspace({
+    workspaceName: 'ws-1',
+    reason: 'Run completed',
+    resources: { KrateWorkspace: [existing] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.equal(result.workspace.status.phase, 'Archived');
+  assert.ok(result.workspace.status.archivedAt, 'Should have archivedAt timestamp');
+  assert.equal(result.workspace.status.archiveReason, 'Run completed');
+});
+
+test('recoverWorkspace sets phase=Active', () => {
+  const controller = createAgentWorkspaceController();
+  const archived = makeWorkspace('ws-2', 'my-repo', 'run-1', 'Archived', {
+    status: { archivedAt: new Date().toISOString(), archiveReason: 'Cleanup' }
+  });
+  const result = controller.recoverWorkspace({
+    workspaceName: 'ws-2',
+    resources: { KrateWorkspace: [archived] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.equal(result.workspace.status.phase, 'Active');
+  assert.equal(result.workspace.status.archivedAt, undefined, 'archivedAt should be cleared');
+  assert.equal(result.workspace.status.archiveReason, undefined, 'archiveReason should be cleared');
+});
+
+test('bindSession adds session to boundSessions', () => {
+  const controller = createAgentWorkspaceController();
+  const existing = makeWorkspace('ws-3', 'my-repo', 'run-2', 'InUse');
+  const result = controller.bindSession({
+    workspaceName: 'ws-3',
+    sessionRef: 'session-1',
+    agent: 'code-agent',
+    namespace: 'krate-org-default',
+    organizationRef: 'default',
+    resources: { KrateWorkspace: [existing] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.workspace, 'Should return updated workspace');
+  assert.equal(result.workspace.status.boundSessions.length, 1, 'Should have one bound session');
+  assert.equal(result.workspace.status.boundSessions[0].sessionRef, 'session-1');
+  assert.equal(result.workspace.status.boundSessions[0].agent, 'code-agent');
+  assert.ok(result.workspace.status.boundSessions[0].boundAt, 'Should have boundAt timestamp');
+});
+
+test('linkWorkItem creates WorkItemWorkspaceLink', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.linkWorkItem({
+    workspaceName: 'ws-4',
+    workItemRef: 'issue-42',
+    workItemKind: 'Issue',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.link, 'Should return a link resource');
+  assert.equal(result.link.kind, 'WorkItemWorkspaceLink');
+  assert.equal(result.link.spec.workItemRef, 'issue-42');
+  assert.equal(result.link.spec.workItemKind, 'Issue');
+  assert.equal(result.link.spec.workspace, 'ws-4');
+  assert.equal(result.link.spec.organizationRef, 'default');
+});
+
+test('linkWorkItemToSession creates WorkItemSessionLink', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.linkWorkItemToSession({
+    workItemRef: 'pr-10',
+    workItemKind: 'PullRequest',
+    sessionRef: 'session-5',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.link, 'Should return a link resource');
+  assert.equal(result.link.kind, 'WorkItemSessionLink');
+  assert.equal(result.link.spec.workItemRef, 'pr-10');
+  assert.equal(result.link.spec.workItemKind, 'PullRequest');
+  assert.equal(result.link.spec.agentSession, 'session-5');
+  assert.equal(result.link.spec.organizationRef, 'default');
+});
+
+test('listWorkspacesForRepo filters by repository', () => {
+  const controller = createAgentWorkspaceController();
+  const ws1 = makeWorkspace('ws-a', 'repo-alpha', 'run-a');
+  const ws2 = makeWorkspace('ws-b', 'repo-beta', 'run-b');
+  const ws3 = makeWorkspace('ws-c', 'repo-alpha', 'run-c');
+
+  const result = controller.listWorkspacesForRepo({
+    repository: 'repo-alpha',
+    resources: { KrateWorkspace: [ws1, ws2, ws3] }
+  });
+
+  assert.equal(result.length, 2, 'Should return workspaces for repo-alpha only');
+  assert.ok(result.every((w) => w.spec.repository === 'repo-alpha'), 'All should belong to repo-alpha');
+});
+
+test('archiveWorkspace on nonexistent returns error', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.archiveWorkspace({
+    workspaceName: 'ws-nonexistent',
+    reason: 'Cleanup',
+    resources: { KrateWorkspace: [] }
+  });
+
+  assert.equal(result.error, true, 'Should fail');
+  assert.equal(result.reason, 'not-found');
+  assert.ok(result.message.includes('ws-nonexistent'), 'Message should mention the workspace name');
+});
+
+test('recoverWorkspace on non-archived returns error', () => {
+  const controller = createAgentWorkspaceController();
+  const active = makeWorkspace('ws-active', 'my-repo', 'run-x', 'InUse');
+  const result = controller.recoverWorkspace({
+    workspaceName: 'ws-active',
+    resources: { KrateWorkspace: [active] }
+  });
+
+  assert.equal(result.error, true, 'Should fail');
+  assert.equal(result.reason, 'not-archived');
+  assert.ok(result.message.includes('not archived'), 'Message should indicate not archived');
+});