@yeaft/webchat-agent 1.0.123 → 1.0.125

package/yeaft/work-center/watcher.js

@@ -0,0 +1,123 @@
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_LEASE_MS = 60_000;
+
+export class WorkItemWatcher {
+  constructor(options) {
+    this.store = options.store;
+    this.controller = options.controller;
+    this.runner = options.runner;
+    this.ownerBootId = options.ownerBootId;
+    this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : () => {};
+    this.pollIntervalMs = Number(options.pollIntervalMs) > 0
+      ? Number(options.pollIntervalMs)
+      : DEFAULT_POLL_INTERVAL_MS;
+    this.leaseMs = Number(options.leaseMs) > 0 ? Number(options.leaseMs) : DEFAULT_LEASE_MS;
+    this.timer = null;
+    this.ticking = false;
+    this.activeRuns = new Map();
+  }
+
+  status() {
+    return {
+      enabled: !!this.timer,
+      activeRuns: this.activeRuns.size,
+      ownerBootId: this.ownerBootId,
+    };
+  }
+
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => { this.tick().catch(() => {}); }, this.pollIntervalMs);
+    this.timer.unref?.();
+    this.tick().catch(() => {});
+  }
+
+  async stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    const active = Array.from(this.activeRuns.values());
+    for (const entry of active) {
+      this.store.interruptRun(
+        entry.runId,
+        this.ownerBootId,
+        entry.leaseEpoch,
+        'Work Center watcher stopped',
+      );
+      entry.abortController.abort('watcher_stopped');
+    }
+    await Promise.allSettled(active.map(entry => entry.promise));
+  }
+
+  abortInvalidWorkItemRuns(workItemId) {
+    for (const entry of this.activeRuns.values()) {
+      if (entry.workItemId !== workItemId) continue;
+      if (!this.store.isActiveRun(entry.runId, this.ownerBootId, entry.leaseEpoch)) {
+        entry.abortController.abort('work_item_state_changed');
+      }
+    }
+  }
+
+  async tick() {
+    // V1 deliberately serializes WorkItem Runs per Agent. Without a dedicated
+    // per-WorkItem workspace manager, concurrent writers could mutate the same
+    // project directory. Parallel execution can be added only with exclusive
+    // workspace leases.
+    if (this.ticking || this.activeRuns.size > 0 || !this.runner) return;
+    this.ticking = true;
+    try {
+      const claim = this.store.claimReadyAction(this.ownerBootId, this.leaseMs);
+      if (!claim) return;
+      const abortController = new AbortController();
+      const key = claim.run.id;
+      const renewEvery = Math.max(1_000, Math.floor(this.leaseMs / 3));
+      const renewal = setInterval(() => {
+        const ok = this.store.renewLease(key, this.ownerBootId, claim.run.leaseEpoch, this.leaseMs);
+        if (!ok) abortController.abort('work_item_lease_lost');
+      }, renewEvery);
+      renewal.unref?.();
+
+      const promise = this.#execute(claim, abortController.signal)
+        .finally(() => {
+          clearInterval(renewal);
+          this.activeRuns.delete(key);
+        });
+      this.activeRuns.set(key, {
+        promise,
+        abortController,
+        workItemId: claim.workItem.id,
+        runId: claim.run.id,
+        leaseEpoch: claim.run.leaseEpoch,
+      });
+      this.onEvent({ type: 'run.started', workItem: this.store.getWorkItemDetail(claim.workItem.id) });
+    } finally {
+      this.ticking = false;
+    }
+  }
+
+  async #execute(claim, signal) {
+    let result;
+    try {
+      result = await this.runner.run({ ...claim, signal, ownerBootId: this.ownerBootId });
+    } catch (err) {
+      if (signal.aborted) return;
+      result = {
+        outcome: err?.retryable === false ? 'failed' : 'retryable',
+        summary: '',
+        evidence: [],
+        error: err?.message || String(err),
+      };
+    }
+    if (signal.aborted) return;
+    try {
+      const workItem = this.controller.submit(
+        claim.run.id,
+        this.ownerBootId,
+        claim.run.leaseEpoch,
+        result,
+      );
+      this.onEvent({ type: 'run.finished', workItem });
+    } catch (err) {
+      if (!/stale|cancelled|already finished/i.test(err?.message || '')) throw err;
+    }
+  }
+}

package/yeaft/work-center/workflow.js

@@ -0,0 +1,99 @@
+const SOFTWARE_CHANGE_STEPS = Object.freeze([
+  { type: 'triage', requiredRole: 'omni' },
+  { type: 'implement', requiredRole: 'linus' },
+  { type: 'review', requiredRole: 'martin' },
+  { type: 'deliver', requiredRole: 'linus' },
+]);
+
+export const WORKFLOW_TEMPLATES = Object.freeze({
+  'software-change': SOFTWARE_CHANGE_STEPS,
+});
+
+export const RUN_OUTCOMES = Object.freeze([
+  'completed',
+  'waiting',
+  'retryable',
+  'failed',
+]);
+
+export function getWorkflowSteps(template = 'software-change') {
+  const steps = WORKFLOW_TEMPLATES[template];
+  if (!steps) throw new Error(`Unsupported Work Center workflow: ${template}`);
+  return steps;
+}
+
+export function getStep(template, type) {
+  return getWorkflowSteps(template).find(step => step.type === type) || null;
+}
+
+export function getNextStep(template, type, result = {}) {
+  const steps = getWorkflowSteps(template);
+  const index = steps.findIndex(step => step.type === type);
+  if (index === -1) throw new Error(`Action type ${type} is not in workflow ${template}`);
+  if (type === 'review') {
+    if (result.reviewDecision === 'changes_requested') {
+      return steps.find(step => step.type === 'implement') || null;
+    }
+    if (result.reviewDecision !== 'approved') {
+      throw new Error('Completed review requires approved or changes_requested');
+    }
+  }
+  return steps[index + 1] || null;
+}
+
+function renderContext(context = []) {
+  if (!Array.isArray(context) || context.length === 0) return '';
+  const blocks = context.map(entry => {
+    const evidence = Array.isArray(entry.evidence) && entry.evidence.length > 0
+      ? `\nEvidence:\n${entry.evidence.map(item => {
+          const status = item.status ? ` [${item.status}]` : '';
+          const ref = item.ref ? ` (${item.ref})` : '';
+          return `- ${item.kind}: ${item.label}${status}${ref}`;
+        }).join('\n')}`
+      : '';
+    const decision = entry.reviewDecision ? `\nReview decision: ${entry.reviewDecision}` : '';
+    const waitingReason = entry.waitingReason ? `\nWaiting reason: ${entry.waitingReason}` : '';
+    const answer = entry.answer ? `\nUser answer: ${entry.answer}` : '';
+    return `### ${entry.type} (${entry.role || 'unknown role'})\n${entry.summary || '(no summary)'}${decision}${waitingReason}${answer}${evidence}`;
+  });
+  return `\n\nPrior Action results:\n${blocks.join('\n\n')}`;
+}
+
+export function actionInstruction(step, workItem, context = []) {
+  const criteria = (workItem.acceptanceCriteria || []).map(item => `- ${item}`).join('\n') || '- No explicit criteria';
+  const common = `WorkItem: ${workItem.title}\nGoal: ${workItem.goal}\nAcceptance criteria:\n${criteria}${renderContext(context)}`;
+  switch (step.type) {
+    case 'triage':
+      return `${common}\n\nAnalyze the request, verify scope and risks, and make the contract executable. Do not implement yet. If the goal or acceptance criteria need refinement, submit a contractPatch.`;
+    case 'implement':
+      return `${common}\n\nImplement the smallest correct change in the supplied work directory. Add and run relevant tests. Use the prior triage/review findings. Do not approve your own work.`;
+    case 'review':
+      return `${common}\n\nReview the implementation and evidence independently. Return approved or changes_requested with concrete findings.`;
+    case 'deliver':
+      return `${common}\n\nDeliver the approved change using the repository release policy. Verify the final remote state and provide evidence.`;
+    default:
+      return common;
+  }
+}
+
+export function initialActionFor(workItem) {
+  const step = getWorkflowSteps(workItem.workflowTemplate)[0];
+  return {
+    ...step,
+    context: [],
+    instruction: actionInstruction(step, workItem, []),
+    maxAttempts: 2,
+  };
+}
+
+export function actionContextFromRuns(runs = []) {
+  return runs
+    .filter(run => run && run.summary)
+    .map(run => ({
+      type: run.actionType || 'action',
+      role: run.roleSnapshot?.id || run.vpSnapshot?.id || null,
+      summary: run.summary,
+      evidence: Array.isArray(run.evidence) ? run.evidence : [],
+      reviewDecision: run.reviewDecision || null,
+    }));
+}