@fitlab-ai/agent-infra 0.8.2 → 0.8.4

package/lib/server/daemon.ts

@@ -1,87 +1,123 @@
 import { VERSION } from '../version.ts';
 import { loadServerConfig } from './config.ts';
+import type { ServerConfig } from './config.ts';
 import { createLogger } from './logger.ts';
+import type { Logger } from './logger.ts';
 import { loadAdapters, unloadAdapters } from './plugin-loader.ts';
 import type { InboundMessage } from './adapters/_contract.ts';
 import { authorize } from './auth.ts';
 import { commandHelp, parseCommand } from './protocol.ts';
 import { runAi } from './runner.ts';
+import type { RunnerOptions, RunnerResult } from './runner.ts';
 import { streamCommand } from './streamer.ts';
+import { markdownMessage, replyOutbound, textMessage } from './display.ts';
+import { buildStatusModel, statusModelToDisplay, type StatusModel } from '../task/commands/status.ts';
 
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-// The daemon main loop. Runs in the detached child spawned by
-// process-control.start(), or in the foreground for debugging.
-//
-// Lifecycle (keep-alive / shutdown model):
-//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
-//     holds the event loop open while subtask A has no adapters, and the
-//     observable signal that `ai server logs -f` shows.
-//   - runDaemon() awaits a shutdown promise that only resolves once a
-//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
-//     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon(): Promise<void> {
-  let config;
-  try {
-    config = loadServerConfig();
-  } catch (error) {
-    process.stderr.write(`${errorMessage(error)}\n`);
-    process.exit(1);
-  }
+type MessageDispatcherOptions = {
+  config: ServerConfig;
+  logger: Pick<Logger, 'info'>;
+  runAi?: (args: string[], options?: RunnerOptions) => Promise<RunnerResult>;
+  buildStatusModel?: (ref: string) => StatusModel;
+  statusModelToDisplay?: (model: StatusModel) => ReturnType<typeof statusModelToDisplay>;
+};
 
-  const logger = createLogger(config.log);
-  logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+function isTaskStatus(argv: string[]): boolean {
+  return argv[0] === 'task' && argv[1] === 'status' && typeof argv[2] === 'string';
+}
 
-  const abortController = new AbortController();
-  let resolveShutdown: () => void = () => {};
-  const shutdown = new Promise<void>((resolve) => {
-    resolveShutdown = resolve;
-  });
+export function createMessageDispatcher(options: MessageDispatcherOptions): (message: InboundMessage) => Promise<void> {
+  const runAiImpl = options.runAi ?? runAi;
+  const buildStatusModelImpl = options.buildStatusModel ?? buildStatusModel;
+  const statusModelToDisplayImpl = options.statusModelToDisplay ?? statusModelToDisplay;
 
-  const dispatch = async (message: InboundMessage): Promise<void> => {
+  return async (message: InboundMessage): Promise<void> => {
     const plan = parseCommand(message.text);
     if (plan.kind === 'ignore') return;
     if (plan.kind === 'error') {
-      await message.reply(plan.message);
-      logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
+      await replyOutbound(message, textMessage(plan.message));
+      options.logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'ping') {
-      await message.reply(`pong ${VERSION}`);
+      await replyOutbound(message, textMessage(`pong ${VERSION}`));
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'help') {
-      await message.reply(commandHelp());
+      await replyOutbound(message, markdownMessage(commandHelp()));
       return;
     }
     if (plan.kind === 'builtin' && plan.name === 'version') {
-      await message.reply(`agent-infra ${VERSION}`);
+      await replyOutbound(message, textMessage(`agent-infra ${VERSION}`));
       return;
     }
     if (plan.kind === 'ai') {
       const allowed = authorize(
         { adapter: message.adapter, userId: message.userId },
         plan.role,
-        config.auth
+        options.config.auth
       );
       if (!allowed.ok) {
-        await message.reply(allowed.message);
-        logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
+        await replyOutbound(message, textMessage(allowed.message));
+        options.logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
         return;
       }
+
+      if (isTaskStatus(plan.argv)) {
+        try {
+          await replyOutbound(message, statusModelToDisplayImpl(buildStatusModelImpl(plan.argv[2]!)));
+          return;
+        } catch {
+          // Fall back to the existing CLI streaming path. This preserves the
+          // old behavior for invalid refs and any status-model collection error.
+        }
+      }
+
       await streamCommand(
         {
           title: `ai ${plan.argv.join(' ')}`,
-          chunkChars: typeof config.stream?.chunkChars === 'number' ? config.stream.chunkChars : 4000,
-          throttleMs: typeof config.stream?.throttleMs === 'number' ? config.stream.throttleMs : 1500
+          chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
+          throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
         },
-        (emit) => runAi(plan.argv, { onChunk: emit }),
-        (text) => message.reply(text)
+        (emit) => runAiImpl(plan.argv, { onChunk: emit }),
+        (outbound) => replyOutbound(message, outbound)
       );
     }
   };
+}
+
+// The daemon main loop. Runs in the detached child spawned by
+// process-control.start(), or in the foreground for debugging.
+//
+// Lifecycle (keep-alive / shutdown model):
+//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
+//     holds the event loop open while subtask A has no adapters, and the
+//     observable signal that `ai server logs -f` shows.
+//   - runDaemon() awaits a shutdown promise that only resolves once a
+//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
+//     the only keep-alive timer (that would let the process exit immediately).
+export async function runDaemon(): Promise<void> {
+  let config;
+  try {
+    config = loadServerConfig();
+  } catch (error) {
+    process.stderr.write(`${errorMessage(error)}\n`);
+    process.exit(1);
+  }
+
+  const logger = createLogger(config.log);
+  logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+
+  const abortController = new AbortController();
+  let resolveShutdown: () => void = () => {};
+  const shutdown = new Promise<void>((resolve) => {
+    resolveShutdown = resolve;
+  });
+
+  const dispatch = createMessageDispatcher({ config, logger });
 
   const ctx = { config, logger, dispatch, signal: abortController.signal };
   const adapters = await loadAdapters(config, ctx);

package/lib/server/display.ts

@@ -0,0 +1,136 @@
+export type OutboundMessage = string | DisplayMessage;
+
+export type DisplayTone = 'info' | 'success' | 'warning' | 'danger' | 'running';
+
+export type DisplayMessage =
+  | { kind: 'text'; text: string }
+  | { kind: 'markdown'; markdown: string }
+  | { kind: 'table'; title?: string; columns: string[]; rows: string[][] }
+  | { kind: 'status-card'; title: string; tone: DisplayTone; fields?: [string, string][]; body?: string }
+  | {
+      kind: 'stream-event';
+      title: string;
+      phase: 'started' | 'chunk' | 'finished';
+      text?: string;
+      exitCode?: number | null;
+      signal?: NodeJS.Signals | null;
+    }
+  | {
+      kind: 'command-result';
+      title: string;
+      exitCode: number | null;
+      signal: NodeJS.Signals | null;
+      stdout?: string;
+      stderr?: string;
+    };
+
+export function textMessage(text: string): DisplayMessage {
+  return { kind: 'text', text };
+}
+
+export function markdownMessage(markdown: string): DisplayMessage {
+  return { kind: 'markdown', markdown };
+}
+
+export function tableMessage(columns: string[], rows: string[][], title?: string): DisplayMessage {
+  return { kind: 'table', title, columns, rows };
+}
+
+export function statusCard(
+  title: string,
+  tone: DisplayTone,
+  fields?: [string, string][],
+  body?: string
+): DisplayMessage {
+  return { kind: 'status-card', title, tone, fields, body };
+}
+
+export function streamEvent(
+  title: string,
+  phase: 'started' | 'chunk' | 'finished',
+  text?: string,
+  exitCode?: number | null,
+  signal?: NodeJS.Signals | null
+): DisplayMessage {
+  const message: Extract<DisplayMessage, { kind: 'stream-event' }> = { kind: 'stream-event', title, phase };
+  if (text !== undefined) message.text = text;
+  if (exitCode !== undefined) message.exitCode = exitCode;
+  if (signal !== undefined) message.signal = signal;
+  return message;
+}
+
+export function commandResult(
+  title: string,
+  exitCode: number | null,
+  signal: NodeJS.Signals | null,
+  stdout?: string,
+  stderr?: string
+): DisplayMessage {
+  return { kind: 'command-result', title, exitCode, signal, stdout, stderr };
+}
+
+export function normalizeOutbound(message: OutboundMessage): DisplayMessage {
+  return typeof message === 'string' ? textMessage(message) : message;
+}
+
+function tableToText(message: Extract<DisplayMessage, { kind: 'table' }>): string {
+  const lines: string[] = [];
+  if (message.title) lines.push(message.title);
+  lines.push(message.columns.join(' | '));
+  lines.push(message.columns.map(() => '---').join(' | '));
+  for (const row of message.rows) {
+    lines.push(row.join(' | '));
+  }
+  return lines.join('\n');
+}
+
+function compact(lines: Array<string | undefined>): string {
+  return lines.filter((line): line is string => typeof line === 'string' && line !== '').join('\n');
+}
+
+function unknownDisplayKind(message: never): string {
+  return `[unknown: ${String((message as { kind?: unknown }).kind)}]`;
+}
+
+export function outboundToText(message: OutboundMessage): string {
+  const normalized = normalizeOutbound(message);
+  switch (normalized.kind) {
+    case 'text':
+      return normalized.text;
+    case 'markdown':
+      return normalized.markdown;
+    case 'table':
+      return tableToText(normalized);
+    case 'status-card':
+      return compact([
+        normalized.title,
+        ...(normalized.fields ?? []).map(([label, value]) => `${label}: ${value}`),
+        normalized.body
+      ]);
+    case 'stream-event':
+      if (normalized.phase === 'started') return `started ${normalized.title}`;
+      if (normalized.phase === 'chunk') return normalized.text ?? '';
+      return `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`;
+    case 'command-result':
+      return compact([
+        `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`,
+        normalized.stdout,
+        normalized.stderr
+      ]);
+  }
+  return unknownDisplayKind(normalized);
+}
+
+export async function replyOutbound(
+  inbound: {
+    reply: (text: string) => Promise<void>;
+    replyDisplay?: (message: OutboundMessage) => Promise<void>;
+  },
+  message: OutboundMessage
+): Promise<void> {
+  if (inbound.replyDisplay) {
+    await inbound.replyDisplay(message);
+    return;
+  }
+  await inbound.reply(outboundToText(message));
+}

package/lib/server/streamer.ts

@@ -1,3 +1,4 @@
+import { streamEvent, type OutboundMessage } from './display.ts';
 import { redactSecrets } from './redact.ts';
 import type { RunnerResult } from './runner.ts';
 
@@ -19,9 +20,9 @@ function chunks(text: string, size: number): string[] {
 export async function streamCommand(
   options: StreamOptions,
   run: (emit?: (chunk: string) => Promise<void>) => Promise<RunnerResult>,
-  send: (text: string) => Promise<void>
+  send: (message: OutboundMessage) => Promise<void>
 ): Promise<RunnerResult> {
-  await send(`started ${options.title}`);
+  await send(streamEvent(options.title, 'started'));
   const size = options.chunkChars ?? 4000;
   const throttleMs = options.throttleMs ?? 0;
   let streamed = false;
@@ -34,7 +35,7 @@ export async function streamCommand(
     buffer = '';
     lastFlush = Date.now();
     for (const chunk of chunks(text, size)) {
-      await send(chunk);
+      await send(streamEvent(options.title, 'chunk', chunk));
     }
   };
 
@@ -52,6 +53,6 @@ export async function streamCommand(
     buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
   }
   await flush();
-  await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+  await send(streamEvent(options.title, 'finished', undefined, result.exitCode, result.signal));
   return result;
 }

package/lib/task/commands/log.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from '../../table.ts';
 import { resolveTaskRef } from '../resolve-ref.ts';
-import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
+import { parseLedger, type LedgerRow } from '../ledger.ts';
 
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
@@ -14,7 +14,7 @@ Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
   a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
   the verdict list, right after blockers/major/minor: manual-validation
-  and human-decision (current ledger stage total).
+  and human-decision (current pending ledger stage total).
 `;
 
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'] as const;
@@ -108,7 +108,7 @@ function pairEntries(entries: LogEntry[]): StepRow[] {
 function countHumanDecisionsByStage(rows: LedgerRow[]): Map<ReviewStage, number> {
   const counts = new Map<ReviewStage, number>();
   for (const row of rows) {
-    if (!isReviewStage(row.stage) || !HUMAN_DECISION_STATUSES.has(row.status)) continue;
+    if (!isReviewStage(row.stage) || row.status !== 'needs-human-decision') continue;
     counts.set(row.stage, (counts.get(row.stage) ?? 0) + 1);
   }
   return counts;

package/lib/task/commands/status.ts

@@ -6,7 +6,9 @@ import { resolveTaskRef } from '../resolve-ref.ts';
 import { enumerateArtifacts, type Artifact } from '../artifacts.ts';
 import { parseTaskFrontmatter, extractTitle, type Frontmatter } from '../frontmatter.ts';
 import { loadShortIdByTaskId } from '../short-id.ts';
+import { getOpenWorkflowWarnings, formatWorkflowWarningSummary, type WorkflowWarning } from '../workflow-warnings.ts';
 import { parseActivityLog, pairEntries } from './log.ts';
+import { statusCard, type DisplayMessage } from '../../server/display.ts';
 
 const USAGE = `Usage: ai task status <N | #N | TASK-id>
 
@@ -322,12 +324,28 @@ type StatusModel = {
   shortId: string;
   title: string;
   metadata: [string, string][];
+  workflowWarnings: WorkflowWarning[];
   artifacts: { count: number; groups: { stage: string; files: string[] }[] };
   workflow: WorkflowInfo;
   runtime: RuntimeInfo;
   git: GitInfo;
 };
 
+type BuildStatusModelInput = {
+  taskId: string;
+  taskDir: string;
+  taskMdPath: string;
+  repoRoot: string;
+  shortId?: string;
+  run?: Runner;
+  now?: Date;
+};
+
+type BuildStatusModelOptions = {
+  run?: Runner;
+  now?: Date;
+};
+
 // Indent each label/value pair by two spaces and pad labels to a common width so
 // every section reads as an aligned "key   value" block.
 function renderPairs(rows: [string, string][]): string[] {
@@ -343,6 +361,14 @@ function renderStatus(model: StatusModel): string[] {
 
   lines.push('', 'Metadata', ...renderPairs(model.metadata));
 
+  if (model.workflowWarnings.length > 0) {
+    lines.push(
+      '',
+      `Workflow Warnings (${model.workflowWarnings.length} open)`,
+      ...formatWorkflowWarningSummary(model.workflowWarnings).map((line) => `  ${line}`)
+    );
+  }
+
   lines.push('', `Artifacts (${model.artifacts.count})`);
   if (model.artifacts.groups.length === 0) {
     lines.push('  (none)');
@@ -394,36 +420,89 @@ function renderStatus(model: StatusModel): string[] {
   return lines;
 }
 
-function status(args: string[] = []): void {
-  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-    process.stdout.write(USAGE);
-    if (args.length === 0) process.exitCode = 1;
-    return;
-  }
-
-  const resolved = resolveTaskRef(args[0]!);
-  if (!resolved.ok) {
-    process.stderr.write(`ai task status: ${resolved.message}\n`);
-    process.exitCode = 1;
-    return;
+function modelTone(model: StatusModel): 'info' | 'success' | 'warning' | 'danger' | 'running' {
+  if (model.workflow.state === 'in-progress') return model.workflow.stale === 'yes' ? 'warning' : 'running';
+  if (model.metadata.some(([key, value]) => key === 'status' && value === 'completed')) return 'success';
+  if (model.metadata.some(([key, value]) => key === 'status' && (value === 'blocked' || value === 'cancelled'))) {
+    return 'danger';
   }
+  return 'info';
+}
 
-  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+function buildFromResolved(input: BuildStatusModelInput): StatusModel {
+  const content = fs.readFileSync(input.taskMdPath, 'utf8');
   const fm = parseTaskFrontmatter(content);
-  const run = makeRunner(resolved.repoRoot);
-  const artifacts = enumerateArtifacts(resolved.taskDir);
-  const workflow = collectWorkflow(content);
+  const run = input.run ?? makeRunner(input.repoRoot);
+  const artifacts = enumerateArtifacts(input.taskDir);
+  const workflow = collectWorkflow(content, input.now);
 
-  const model: StatusModel = {
-    taskId: resolved.taskId,
-    shortId: loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId) ?? DASH,
+  return {
+    taskId: input.taskId,
+    shortId: input.shortId ?? loadShortIdByTaskId(input.repoRoot).get(input.taskId) ?? DASH,
     title: extractTitle(content),
     metadata: collectMetadata(fm),
+    workflowWarnings: getOpenWorkflowWarnings(content),
     artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
     workflow,
-    runtime: collectRuntime(resolved.taskDir, workflow, run),
+    runtime: collectRuntime(input.taskDir, workflow, run),
     git: collectGit(fm.branch ?? '', run)
   };
+}
+
+function buildStatusModel(ref: string, options?: BuildStatusModelOptions): StatusModel;
+function buildStatusModel(input: BuildStatusModelInput): StatusModel;
+function buildStatusModel(
+  refOrInput: string | BuildStatusModelInput,
+  options: BuildStatusModelOptions = {}
+): StatusModel {
+  if (typeof refOrInput !== 'string') {
+    return buildFromResolved(refOrInput);
+  }
+
+  const resolved = resolveTaskRef(refOrInput);
+  if (!resolved.ok) {
+    throw new Error(resolved.message);
+  }
+
+  return buildFromResolved({
+    taskId: resolved.taskId,
+    taskDir: resolved.taskDir,
+    taskMdPath: resolved.taskMdPath,
+    repoRoot: resolved.repoRoot,
+    run: options.run,
+    now: options.now
+  });
+}
+
+function statusModelToDisplay(model: StatusModel): DisplayMessage {
+  return statusCard(
+    `Task ${model.taskId} (${model.shortId})`,
+    modelTone(model),
+    [
+      ['workflow', model.workflow.state],
+      ['step', model.workflow.step],
+      ['runtime', model.runtime.status],
+      ['git', model.git.uncommitted]
+    ],
+    renderStatus(model).join('\n')
+  );
+}
+
+function status(args: string[] = []): void {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    if (args.length === 0) process.exitCode = 1;
+    return;
+  }
+
+  let model: StatusModel;
+  try {
+    model = buildStatusModel(args[0]!);
+  } catch (error) {
+    process.stderr.write(`ai task status: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+    return;
+  }
 
   for (const line of renderStatus(model)) {
     process.stdout.write(`${line}\n`);
@@ -433,12 +512,14 @@ function status(args: string[] = []): void {
 export {
   status,
   makeRunner,
+  buildStatusModel,
   collectMetadata,
   groupArtifacts,
   collectGit,
   collectWorkflow,
   collectRuntime,
   renderStatus,
+  statusModelToDisplay,
   METADATA_KEYS
 };
-export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, StatusModel };
+export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, StatusModel, BuildStatusModelInput };

package/lib/task/workflow-warnings.ts

@@ -0,0 +1,121 @@
+import { extractSection } from './sections.ts';
+
+const WORKFLOW_WARNING_HEADINGS = ['工作流告警', 'Workflow Warnings'];
+const WORKFLOW_WARNING_STATUSES = new Set(['open', 'resolved', 'ignored']);
+const WORKFLOW_WARNING_SEVERITIES = new Set(['IMPORTANT', 'ACTION_REQUIRED']);
+
+type WorkflowWarning = {
+  id: string;
+  time: string;
+  step: string;
+  severity: string;
+  code: string;
+  status: string;
+  target: string;
+  message: string;
+  action: string;
+  resolvedAt: string;
+  resolution: string;
+};
+
+function splitTableRow(line: string): string[] {
+  let value = line.trim();
+  if (!value.startsWith('|')) return [];
+  value = value.replace(/^\|/, '').replace(/\|$/, '');
+
+  const cells: string[] = [];
+  let cell = '';
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index]!;
+    if (char === '|' && !isEscapedAt(value, index)) {
+      cells.push(unescapeTableCell(cell.trim()));
+      cell = '';
+      continue;
+    }
+    cell += char;
+  }
+  cells.push(unescapeTableCell(cell.trim()));
+  return cells;
+}
+
+function unescapeTableCell(value: string): string {
+  let output = '';
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index]!;
+    const next = value[index + 1];
+    if (char === '\\' && (next === '\\' || next === '|')) {
+      output += next;
+      index += 1;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function isEscapedAt(value: string, index: number): boolean {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === '\\'; cursor -= 1) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
+function isSeparatorRow(cells: string[]): boolean {
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+
+/**
+ * Parses well-formed workflow warning rows. Malformed rows are intentionally
+ * ignored here; validate-artifact is responsible for reporting structure errors.
+ */
+function parseWorkflowWarnings(content: string): WorkflowWarning[] {
+  const section = extractSection(content, WORKFLOW_WARNING_HEADINGS);
+  if (!section) return [];
+
+  const rows: WorkflowWarning[] = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const cells = splitTableRow(rawLine);
+    if (cells.length === 0) continue;
+    if ((cells[0] ?? '').toLowerCase() === 'id') continue;
+    if (isSeparatorRow(cells)) continue;
+    if (cells.length < 11) continue;
+
+    rows.push({
+      id: cells[0] ?? '',
+      time: cells[1] ?? '',
+      step: cells[2] ?? '',
+      severity: cells[3] ?? '',
+      code: cells[4] ?? '',
+      status: cells[5] ?? '',
+      target: cells[6] ?? '',
+      message: cells[7] ?? '',
+      action: cells[8] ?? '',
+      resolvedAt: cells[9] ?? '',
+      resolution: cells[10] ?? ''
+    });
+  }
+  return rows;
+}
+
+function getOpenWorkflowWarnings(content: string): WorkflowWarning[] {
+  return parseWorkflowWarnings(content).filter((warning) => warning.status === 'open');
+}
+
+function formatWorkflowWarningSummary(warnings: readonly WorkflowWarning[]): string[] {
+  return warnings.map((warning) => {
+    const target = warning.target ? ` ${warning.target}` : '';
+    const action = warning.action ? ` - ${warning.action}` : '';
+    return `${warning.id} [${warning.severity}] ${warning.code}${target}${action}`;
+  });
+}
+
+export {
+  WORKFLOW_WARNING_HEADINGS,
+  WORKFLOW_WARNING_STATUSES,
+  WORKFLOW_WARNING_SEVERITIES,
+  parseWorkflowWarnings,
+  getOpenWorkflowWarnings,
+  formatWorkflowWarningSummary
+};
+export type { WorkflowWarning };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Gemini CLI, and OpenCode",
   "license": "MIT",
   "type": "module",
@@ -67,7 +67,7 @@
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.20.0",
     "@types/semver": "^7.7.1",
-    "typescript": "~6.0"
+    "typescript": "~7.0"
   },
   "optionalDependencies": {
     "@lydell/node-pty": "^1.2.0-beta.12"