agents-relay 1.0.74 → 1.0.76

package/README.md

@@ -135,6 +135,8 @@ events, durable-thread reuse, resume, or retry behavior.
 
 Open the dashboard on localhost port 8787. The marker format is intentionally public and append-friendly; the CLI uses GitHubStore with the authenticated gh client in operational mode.
 
+External product feedback uses the reusable `src/feedback.ts` contract. See [docs/feedback-intake.md](docs/feedback-intake.md) for the schema, attachment limits, privacy rules, materialization path, and provenance envelope for later Jobs/Tasks/PRs.
+
 reconcile leases and launches ready tasks without waiting inside the runtime scheduler; the CLI waits only long enough for its launched workers to persist results. agents-relayd (or the equivalent npx agents-relay serve) is the watchdog/dashboard mode. Model-backed workers require --events nats; the event transport carries authoritative terminal worker events as well as wake/progress traffic. See [docs/service.md](docs/service.md). --file PATH is explicit local demo/test mode only.
 
 `agents-relayd` without `--pr`/`--id` runs in workspace mode by default: it discovers nested Git repositories under `~/Workspace`, keeps only GitHub `origin` remotes, and aggregates their managed PR jobs into one dashboard and worker pool. Pass `--workspace PATH` to use another root. `--repo OWNER/REPO` remains the single-repository pool mode.

package/dist/cli.js

@@ -673,6 +673,32 @@ async function runJobCommand(action, args) {
 export function runtimePlanner(args) { const plannerCommand = arg([...args], '--planner-command'); const modelRuntime = arg([...args], '--codex', 'codex'); return plannerCommand ? new CommandObjectivePlanner(plannerCommand) : new AgentObjectivePlanner(modelRuntime); }
 export function runtimeReviewer() { return { requirements: { capabilities: ['model'] } }; }
 export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: job => resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()) }); }
+export function dashboardTaskAction(store, reconciler, action) {
+    return async (jobId, taskId) => {
+        const job = await store.load(jobId);
+        const task = job.tasks.find(item => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        if (action === 'retry') {
+            if (!['FAILED', 'BLOCKED'].includes(task.state))
+                throw new Error(`Task ${task.id} is not restartable (${task.state})`);
+            task.maxAttempts = extendRetryBudget(task);
+            await transitionTaskEvent(task, 'retry');
+            task.error = null;
+        }
+        else {
+            if (!['DRAFT', 'QUEUED', 'BLOCKED', 'FAILED'].includes(task.state))
+                throw new Error(`Task ${task.id} is not cancellable (${task.state})`);
+            await transitionTaskEvent(task, 'cancel');
+            task.error = 'Cancelled by user';
+        }
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+        task.executionId = null;
+        await store.saveTask(task);
+        return await reconciler.wake(job.id);
+    };
+}
 export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
@@ -724,6 +750,8 @@ export async function createService(args) {
         start: dashboardJobAction(loaded.store, reconciler, 'start'),
         reconcile: dashboardJobAction(loaded.store, reconciler, 'reconcile'),
         cancel: dashboardJobAction(loaded.store, reconciler, 'cancel'),
+        taskRetry: dashboardTaskAction(loaded.store, reconciler, 'retry'),
+        taskCancel: dashboardTaskAction(loaded.store, reconciler, 'cancel'),
     });
     await once(dashboardServer, 'listening');
     const stopWatcher = await reconciler.watch(loaded.job.id);

package/dist/dashboard.js

@@ -124,6 +124,7 @@ export const dashboardHtml = `<!doctype html>
     .task-row { width:100%; display:flex; align-items:center; gap:.4rem; min-width:0; padding:.32rem .38rem; border:0; border-radius:.35rem; background:transparent; color:inherit; font:inherit; text-align:left; cursor:pointer; }
     .task-row[aria-current="true"] { background:var(--accent2); }
     .task-id { min-width:0; flex:1; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font: .77rem ui-monospace,SFMono-Regular,Menlo,monospace; }
+    .task-actions { display:flex; justify-content:flex-end; gap:.25rem; margin-bottom:.5rem; }
     .event-list { display:grid; gap:.45rem; }
     .event-item { padding-bottom:.4rem; border-bottom:1px solid var(--border); }
     .event-meta { display:flex; flex-wrap:wrap; gap:.4rem; color:var(--muted); font-size:.68rem; }
@@ -274,7 +275,10 @@ function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();
 function taskNode(task,children,depth){const li=element('li');const row=document.createElement('button');row.type='button';row.className='task-row';row.setAttribute('aria-current',String(task.id===selectedTaskId));row.title=task.id;row.addEventListener('click',()=>{selectedTaskId=task.id;eventTaskId=task.id;rememberSelection();clearEvents();renderAll();void loadEventHistory();});const id=element('span','task-id',text(task.id));id.style.paddingLeft=Math.min(depth,4)*6+'px';row.append(id,element('span','badge '+value(task.state),text(task.state)));li.append(row);const nested=children.get(task.id)||[];if(nested.length){const ul=element('ul','tree');for(const child of nested)ul.append(taskNode(child,children,depth+1));li.append(ul);}return li;}
 function buildTree(tasks){taskTree.replaceChildren();if(!Array.isArray(tasks)||!tasks.length){taskTree.append(element('li','empty',text('No tasks in durable state.')));return;}const known=new Set(tasks.map(task=>task.id));const children=new Map();const roots=[];for(const task of tasks){if(!task.parentTaskId||!known.has(task.parentTaskId))roots.push(task);else{const siblings=children.get(task.parentTaskId)||[];siblings.push(task);children.set(task.parentTaskId,siblings);}}for(const task of roots)taskTree.append(taskNode(task,children,0));}
 function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Number(task?.maxAttempts)||0;if(max>=3&&max%3===0){const effectiveMax=Math.max(max,Math.ceil(attempt/3)*3);return attempt+' / 3×'+(effectiveMax/3);}return attempt+' / '+max;}
-function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Task',task.id),field('Kind',task.kind||'work'),field('State',task.state),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),chatField(task));if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(groups);}
+function taskActionEnabled(task,action){if(action==='retry')return ['FAILED','BLOCKED'].includes(task.state);if(action==='cancel')return ['DRAFT','QUEUED','BLOCKED','FAILED'].includes(task.state);return false;}
+function taskActionButton(task,action,label,icon){const button=document.createElement('button');button.type='button';button.className='job-action';button.textContent=icon;button.title=label;button.setAttribute('aria-label',label);button.disabled=!taskActionEnabled(task,action);button.addEventListener('click',()=>void runTaskAction(task,action,button));return button;}
+async function runTaskAction(task,action,button){const job=selected();if(!job)return;button.disabled=true;try{const response=await fetch('/api/task-action?id='+encodeURIComponent(job.id)+'&task='+encodeURIComponent(task.id)+'&action='+encodeURIComponent(action),{method:'POST'});if(!response.ok)throw new Error(response.status+' '+response.statusText);const updated=await response.json();const index=jobs.findIndex(candidate=>candidate.id===job.id);if(index>=0)jobs[index]=updated;else jobs.push(updated);renderAll();void loadEventHistory();}catch(error){button.title=(action==='retry'?'Restart':'Cancel')+': '+error.message;}finally{renderAll();}}
+function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const actions=element('div','task-actions');actions.append(taskActionButton(task,'retry','Restart task','↻'),taskActionButton(task,'cancel','Cancel task','×'));const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Task',task.id),field('Kind',task.kind||'work'),field('State',task.state),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),chatField(task));if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(actions,groups);}
 function reviewStatus(job){const review=job?.review;if(!review)return 'Not started';if(review.outcome==='approved'&&review.headSha===job.headSha)return 'MERGE READY · approved';const stale=Array.isArray(job?.tasks)&&job.tasks.some(task=>task.agentName==='reviewer'&&task.reviewHeadSha&&job.headSha&&task.reviewHeadSha!==job.headSha);if(stale)return 'STALE · awaiting review';return String(review.outcome||'pending').replace('_',' ').toUpperCase();}
 function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent=value(job.title||job.id);if(job.id!==selectedJob){selectedJob=job.id;selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('PR state',job.githubState||'UNKNOWN'),field('Lifecycle state',job.state),field('Runtime status',job.runtimeStatus||'IDLE'),field('Execution mode',job.executionMode||'fixed'),field('Review',reviewStatus(job)),field('Review head SHA',job.review?.headSha||job.headSha||'—'),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(job.tasks)));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}
 function renderAll(){jobs.sort(compareJobs);syncFilters();renderJobList();renderSelectedJob();}
@@ -485,6 +489,27 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
             return;
         }
+        if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/task-action') {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            const requestedJobId = url.searchParams.get('id') ?? '';
+            const requestedTaskId = url.searchParams.get('task') ?? '';
+            const action = url.searchParams.get('action') ?? '';
+            const handler = action === 'retry' ? actions?.taskRetry : action === 'cancel' ? actions?.taskCancel : undefined;
+            if (req.method !== 'POST' || !/^[A-Za-z0-9_-]+$/.test(requestedJobId) || !/^[A-Za-z0-9_-]+$/.test(requestedTaskId) || !handler) {
+                res.writeHead(404);
+                res.end('Task action unavailable');
+                return;
+            }
+            try {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(await handler(requestedJobId, requestedTaskId)));
+            }
+            catch (error) {
+                res.writeHead(409);
+                res.end(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/job') {
             try {
                 const requestedJobId = new URL(req.url ?? '/', 'http://127.0.0.1').searchParams.get('id') ?? undefined;

package/dist/feedback.js

@@ -0,0 +1,234 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, join, resolve } from 'node:path';
+export const FEEDBACK_MARKER = 'agents-relay:feedback:v1';
+export const FEEDBACK_SCHEMA = 'agents-relay.feedback';
+export const FEEDBACK_SCHEMA_VERSION = 1;
+export const FEEDBACK_MAX_TEXT_LENGTH = 20_000;
+export const FEEDBACK_MAX_ATTACHMENTS = 10;
+export const FEEDBACK_MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+export const FEEDBACK_IMAGE_TYPES = ['image/gif', 'image/jpeg', 'image/png', 'image/webp'];
+export const DEFAULT_FEEDBACK_LIMITS = {
+    maxTextLength: 20_000,
+    maxAttachments: 5,
+    maxAttachmentBytes: 10 * 1024 * 1024,
+    allowedMediaTypes: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'],
+};
+function effectiveLimits(limits = {}) {
+    return {
+        maxTextLength: limits.maxTextLength ?? DEFAULT_FEEDBACK_LIMITS.maxTextLength,
+        maxAttachments: limits.maxAttachments ?? DEFAULT_FEEDBACK_LIMITS.maxAttachments,
+        maxAttachmentBytes: limits.maxAttachmentBytes ?? DEFAULT_FEEDBACK_LIMITS.maxAttachmentBytes,
+        allowedMediaTypes: limits.allowedMediaTypes ?? DEFAULT_FEEDBACK_LIMITS.allowedMediaTypes,
+    };
+}
+function fail(message) { throw new Error(`Invalid feedback: ${message}`); }
+function safeId(id) {
+    if (!/^[a-f0-9-]{36}$/i.test(id))
+        fail('feedback id is invalid');
+    return id;
+}
+function cleanFilename(filename) {
+    const cleaned = basename(filename).replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 120);
+    if (!cleaned || cleaned === '.' || cleaned === '..')
+        fail('attachment filename is invalid');
+    return cleaned;
+}
+function cleanOptional(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (value.length > 500)
+        fail(`${field} is too long`);
+    return value;
+}
+function validateProvenance(input) {
+    if (!input.product.trim())
+        fail('provenance.product is required');
+    if (!input.submittedAt || Number.isNaN(Date.parse(input.submittedAt)))
+        fail('provenance.submittedAt must be an ISO timestamp');
+    if (input.contact && !input.contact.value.trim())
+        fail('contact value must not be empty');
+    // Only the explicitly documented fields are copied. Upload/browser/provider metadata is never persisted.
+    return {
+        source: input.source,
+        product: input.product.trim().slice(0, 200),
+        surface: cleanOptional(input.surface, 'surface'),
+        setupStep: cleanOptional(input.setupStep, 'setupStep'),
+        actorClass: input.actorClass,
+        version: cleanOptional(input.version, 'version'),
+        build: cleanOptional(input.build, 'build'),
+        submittedAt: new Date(input.submittedAt).toISOString(),
+        ...(input.contact ? { contact: { channel: input.contact.channel, value: input.contact.value.trim().slice(0, 500) } } : {}),
+    };
+}
+export function marker(label, value) {
+    return `<!-- ${label} ${JSON.stringify(value).replace(/>/g, '\\u003e')} -->`;
+}
+export function renderFeedbackMarker(record) {
+    const { userContent: _userContent, ...metadata } = record;
+    return marker(FEEDBACK_MARKER, metadata);
+}
+export function parseFeedbackMarker(value) {
+    const match = value.match(/<!--\s*agents-relay:feedback:v1\s+([\s\S]*?)\s*-->/);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        return parsed.schema === FEEDBACK_MARKER && parsed.schemaVersion === FEEDBACK_SCHEMA_VERSION ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export class FileFeedbackStore {
+    root;
+    limits;
+    constructor(root, limits = {}) {
+        this.root = resolve(root);
+        this.limits = effectiveLimits(limits);
+    }
+    async submit(submission) {
+        const existing = submission.idempotencyKey ? await this.findByIdempotencyKey(submission.idempotencyKey) : null;
+        if (existing)
+            return { record: existing, recordRef: this.recordPath(existing.id) };
+        const text = submission.text.trim();
+        if (!text)
+            fail('text is required');
+        if (text.length > this.limits.maxTextLength)
+            fail(`text exceeds ${this.limits.maxTextLength} characters`);
+        const inputs = submission.attachments ?? [];
+        if (inputs.length > this.limits.maxAttachments)
+            fail(`at most ${this.limits.maxAttachments} attachments are allowed`);
+        const now = new Date().toISOString();
+        const id = randomUUID();
+        const attachmentDir = join(this.root, 'attachments', id);
+        const attachments = [];
+        await mkdir(attachmentDir, { recursive: true });
+        try {
+            for (const input of inputs) {
+                if (!this.limits.allowedMediaTypes.includes(input.mediaType.toLowerCase()))
+                    fail(`unsupported attachment type: ${input.mediaType}`);
+                if (input.data.byteLength === 0 || input.data.byteLength > this.limits.maxAttachmentBytes)
+                    fail(`attachment exceeds ${this.limits.maxAttachmentBytes} bytes`);
+                const attachmentId = randomUUID();
+                const filename = cleanFilename(input.filename);
+                const relative = join('attachments', id, `${attachmentId}-${filename}`);
+                await writeFile(join(this.root, relative), input.data, { flag: 'wx' });
+                attachments.push({ id: attachmentId, filename, mediaType: input.mediaType.toLowerCase(), sizeBytes: input.data.byteLength, sha256: createHash('sha256').update(input.data).digest('hex'), storageRef: relative, uploadedAt: now });
+            }
+            const record = {
+                schema: FEEDBACK_MARKER, schemaVersion: FEEDBACK_SCHEMA_VERSION, id,
+                ...(submission.idempotencyKey ? { idempotencyKey: submission.idempotencyKey } : {}),
+                userContent: { text }, attachments, systemProvenance: validateProvenance(submission.provenance),
+                triage: { status: 'new', updatedAt: now }, downstream: [], createdAt: now,
+            };
+            await mkdir(join(this.root, 'records'), { recursive: true });
+            const recordRef = this.recordPath(id);
+            const temp = `${recordRef}.${randomUUID()}.tmp`;
+            await writeFile(temp, `${JSON.stringify(record, null, 2)}\n`, { encoding: 'utf8', flag: 'wx' });
+            await rename(temp, recordRef);
+            return { record, recordRef };
+        }
+        catch (error) {
+            await this.removeAttachmentDirectory(attachmentDir);
+            throw error;
+        }
+    }
+    async read(id) {
+        const parsed = JSON.parse(await readFile(this.recordPath(safeId(id)), 'utf8'));
+        if (parsed.schema !== FEEDBACK_MARKER || parsed.schemaVersion !== FEEDBACK_SCHEMA_VERSION)
+            fail('record schema is unsupported');
+        return parsed;
+    }
+    recordPath(id) { return join(this.root, 'records', `${id}.json`); }
+    async findByIdempotencyKey(key) {
+        const directory = join(this.root, 'records');
+        let entries;
+        try {
+            entries = await readdir(directory);
+        }
+        catch {
+            return null;
+        }
+        for (const entry of entries.filter(item => item.endsWith('.json'))) {
+            const record = JSON.parse(await readFile(join(directory, entry), 'utf8'));
+            if (record.idempotencyKey === key)
+                return record;
+        }
+        return null;
+    }
+    async removeAttachmentDirectory(path) {
+        try {
+            await rm(path, { recursive: true, force: true });
+        }
+        catch { /* best-effort cleanup; the record was not materialized */ }
+    }
+}
+export async function materializeFeedbackRecord(root, submission, limits) {
+    return new FileFeedbackStore(root, limits).submit(submission);
+}
+/** Redacts common bearer/API-key shapes before a product stores user text. */
+export function redactSensitiveText(text) {
+    return text
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [REDACTED]')
+        .replace(/\b(?:sk|pk)_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED_KEY]')
+        .replace(/\b(?:api[_-]?key|token|secret)\s*[:=]\s*[^\s,;]+/gi, '$1=[REDACTED]');
+}
+export function createFeedbackRecord(submission, options = {}) {
+    if (typeof submission.text !== 'string' || submission.text.length === 0 || submission.text.length > FEEDBACK_MAX_TEXT_LENGTH)
+        fail(`text must contain 1-${FEEDBACK_MAX_TEXT_LENGTH} characters`);
+    const attachments = (submission.attachments ?? []).map((input, index) => {
+        if (!FEEDBACK_IMAGE_TYPES.includes(input.mimeType))
+            fail(`attachments[${index}] has an unsupported image format`);
+        if (!Number.isSafeInteger(input.sizeBytes) || input.sizeBytes <= 0 || input.sizeBytes > FEEDBACK_MAX_ATTACHMENT_BYTES)
+            fail(`attachments[${index}] exceeds the ${FEEDBACK_MAX_ATTACHMENT_BYTES} byte limit`);
+        if (!input.reference || input.reference.length > 2_000 || /[?#]/.test(input.reference) || /:\/\/[^/]*:[^@]+@/.test(input.reference))
+            fail('attachment reference must be a stable, credential-free reference');
+        return { ...input, id: `attachment-${index + 1}` };
+    });
+    if (attachments.length > FEEDBACK_MAX_ATTACHMENTS)
+        fail(`at most ${FEEDBACK_MAX_ATTACHMENTS} attachments are supported`);
+    const visibility = submission.visibility ?? 'private';
+    const sanitized = options.sanitize === true || submission.sanitized === true;
+    if (visibility === 'public' && !sanitized)
+        fail('public feedback must be explicitly sanitized');
+    const provenance = validateProvenance(submission.provenance);
+    return {
+        schema: FEEDBACK_SCHEMA, schemaVersion: FEEDBACK_SCHEMA_VERSION, id: options.id ?? `feedback-${randomUUID()}`,
+        userContent: { text: sanitized ? redactSensitiveText(submission.text) : submission.text }, attachments, provenance,
+        systemMetadata: { receivedAt: options.receivedAt ?? new Date().toISOString(), visibility, sanitized },
+        ...(submission.contact ? { contact: submission.contact } : {}), triage: { status: 'new' }, downstream: { work: [] },
+    };
+}
+export function feedbackWorkProvenance(record) {
+    return { feedbackId: record.id, feedbackSchema: `${record.schema}/v${record.schemaVersion}`, feedbackReference: `feedback://${record.id}`, feedbackSubmittedAt: record.provenance.submittedAt };
+}
+export function feedbackFingerprint(record) {
+    return createHash('sha256').update(JSON.stringify({ text: record.userContent.text, attachments: record.attachments.map(item => item.sha256 ?? item.reference), provenance: record.provenance })).digest('hex');
+}
+export function renderFeedbackMarkdown(record) {
+    const markerBody = { schema: record.schema, schemaVersion: record.schemaVersion, id: record.id, provenance: record.provenance, attachmentIds: record.attachments.map(item => item.id), triage: record.triage, downstream: record.downstream };
+    const attachments = record.attachments.length === 0 ? '_None._' : record.attachments.map(item => `- ${item.id}: ${item.mimeType}, ${item.sizeBytes} bytes, ref \`${item.reference}\``).join('\n');
+    return `${marker(FEEDBACK_MARKER, markerBody)}\n# Feedback ${record.id}\n\n## User report\n\n${record.userContent.text}\n\n## Attachments\n\n${attachments}\n`;
+}
+export async function materializeFeedback(first, second, third) {
+    if (typeof first === 'string')
+        return materializeFeedbackRecord(first, second, third);
+    const path = second;
+    const format = third ?? 'json';
+    if (!path || path.includes('\0'))
+        throw new Error('Feedback materialization path is invalid');
+    await mkdir(resolve(path, '..'), { recursive: true });
+    const body = format === 'markdown' ? renderFeedbackMarkdown(first) : `${JSON.stringify(first, null, 2)}\n`;
+    await writeFile(path, body, { encoding: 'utf8', mode: 0o600 });
+}
+export async function readFeedbackAttachment(root, attachment) {
+    const path = resolve(root, attachment.storageRef);
+    const rootPath = resolve(root);
+    if (!path.startsWith(`${rootPath}/`))
+        fail('attachment reference escapes storage root');
+    const bytes = await readFile(path);
+    if (bytes.byteLength !== attachment.sizeBytes || createHash('sha256').update(bytes).digest('hex') !== attachment.sha256)
+        fail('attachment integrity check failed');
+    return bytes;
+}

package/dist/relayd.js

@@ -11,7 +11,7 @@ import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
 import { Reconciler } from './reconciler.js';
 import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestGraphql } from './store.js';
 import { githubAuthContext } from './github-auth.js';
-import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
+import { dashboardJobAction, dashboardTaskAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
@@ -127,6 +127,13 @@ export async function runDaemon(argv) {
         const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
         return await dashboardJobAction(store, makeReconciler(store, concurrency), action)(jobId);
     };
+    const workspaceTaskAction = (action) => async (jobId, taskId) => {
+        const overview = cachedOverviews.find(item => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        return await dashboardTaskAction(store, makeReconciler(store, concurrency), action)(jobId, taskId);
+    };
     const secretFile = value(argv, '--github-webhook-secret-file');
     const secret = value(argv, '--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || (secretFile ? (await readFile(secretFile, 'utf8')).trim() : '');
     const webhook = secret ? {
@@ -170,6 +177,8 @@ export async function runDaemon(argv) {
         start: workspaceJobAction('start'),
         reconcile: workspaceJobAction('reconcile'),
         cancel: workspaceJobAction('cancel'),
+        taskRetry: workspaceTaskAction('retry'),
+        taskCancel: workspaceTaskAction('cancel'),
     });
     await once(server, 'listening');
     const reconcileSafely = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {