ddchat 0.1.0

package/src/inbound.ts

@@ -0,0 +1,379 @@
+import type { IncomingMessage } from "node:http";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { getDdchatState } from "./runtime.js";
+import { resolveDdchatAccount } from "./types.js";
+
+type InboundReq = IncomingMessage & { body?: unknown; rawBody?: unknown };
+
+type DdchatInboundFile = {
+  name?: string;
+  type?: string;
+  mimeType?: string;
+  base64?: string;
+  url?: string;
+};
+
+type DdchatInboundPayload = {
+  accountId?: string;
+  messageId?: string;
+  chatType?: "direct" | "group";
+  userId?: string;
+  groupId?: string;
+  text?: string;
+  files?: DdchatInboundFile[];
+  // legacy compatibility fields
+  mediaUrl?: string;
+  mediaType?: string;
+  mediaName?: string;
+  type?: "text" | "image" | "file" | "audio";
+};
+
+function parseBodyLike(raw: unknown): DdchatInboundPayload {
+  if (!raw) {
+    return {};
+  }
+  if (typeof raw === "object" && !Buffer.isBuffer(raw)) {
+    return raw as DdchatInboundPayload;
+  }
+  const text = Buffer.isBuffer(raw) ? raw.toString("utf-8") : String(raw);
+  if (!text.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed ? (parsed as DdchatInboundPayload) : {};
+  } catch {
+    return {};
+  }
+}
+
+async function readRawBodyFromStream(req: IncomingMessage): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+async function readBody(req: InboundReq): Promise<DdchatInboundPayload> {
+  const direct = req.rawBody ?? req.body;
+  if (direct !== undefined) {
+    return parseBodyLike(direct);
+  }
+  const rawText = await readRawBodyFromStream(req);
+  return parseBodyLike(rawText);
+}
+
+function resolveMediaFetchMaxBytes(
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>,
+): number | undefined {
+  const mb = cfg.agents?.defaults?.mediaMaxMb;
+  if (!mb || mb <= 0) {
+    return undefined;
+  }
+  return mb * 1024 * 1024;
+}
+
+function resolveInboundIdentity(body: DdchatInboundPayload): {
+  messageId: string;
+  chatType: "direct" | "group";
+  userId: string;
+  groupId?: string;
+} {
+  const messageId = String(body.messageId ?? "").trim();
+  const chatType = body.chatType === "group" ? "group" : "direct";
+  const userId = String(body.userId ?? "").trim();
+  const groupId = String(body.groupId ?? "").trim();
+  if (!messageId) {
+    throw new Error("missing messageId");
+  }
+  if (!userId) {
+    throw new Error("missing userId");
+  }
+  if (chatType === "group" && !groupId) {
+    throw new Error("missing groupId for group chatType");
+  }
+  return {
+    messageId,
+    chatType,
+    userId,
+    groupId: groupId || undefined,
+  };
+}
+
+function toInboundFiles(body: DdchatInboundPayload): DdchatInboundFile[] {
+  if (Array.isArray(body.files) && body.files.length > 0) {
+    return body.files;
+  }
+  if (body.mediaUrl) {
+    return [
+      {
+        name: body.mediaName,
+        type: body.mediaType,
+        url: body.mediaUrl,
+      },
+    ];
+  }
+  return [];
+}
+
+async function resolveInboundMedia(params: {
+  channelRuntime: OpenClawPluginApi["runtime"]["channel"];
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>;
+  files: DdchatInboundFile[];
+  logInfo?: (message: string) => void;
+}): Promise<Array<{ path: string; contentType?: string }>> {
+  const out: Array<{ path: string; contentType?: string }> = [];
+  const maxBytes = resolveMediaFetchMaxBytes(params.cfg);
+
+  for (const file of params.files) {
+    const name = typeof file.name === "string" ? file.name : undefined;
+    const mediaType =
+      (typeof file.type === "string" && file.type.trim()) ||
+      (typeof file.mimeType === "string" && file.mimeType.trim()) ||
+      undefined;
+    const base64 = typeof file.base64 === "string" ? file.base64.trim() : "";
+    const url = typeof file.url === "string" ? file.url.trim() : "";
+    try {
+      let buffer: Buffer;
+      let contentType = mediaType;
+      if (base64) {
+        buffer = Buffer.from(base64, "base64");
+      } else if (url) {
+        const fetched = await params.channelRuntime.media.fetchRemoteMedia({
+          url,
+          maxBytes,
+        });
+        buffer = fetched.buffer;
+        contentType = fetched.contentType ?? contentType;
+      } else {
+        continue;
+      }
+      const saved = await params.channelRuntime.media.saveMediaBuffer(
+        buffer,
+        contentType,
+        "inbound/ddchat",
+        maxBytes,
+        name,
+      );
+      out.push({
+        path: saved.path,
+        contentType: saved.contentType ?? contentType,
+      });
+    } catch (error) {
+      params.logInfo?.(`ddchat media parse failed: ${String(error)}`);
+    }
+  }
+  return out;
+}
+
+function inferBodyFromMedia(mediaList: Array<{ contentType?: string }>): string {
+  const firstType = mediaList[0]?.contentType;
+  if (!firstType) {
+    return "<media:file>";
+  }
+  if (firstType.startsWith("image/")) {
+    return "<media:image>";
+  }
+  if (firstType.startsWith("audio/")) {
+    return "<media:audio>";
+  }
+  if (firstType.startsWith("video/")) {
+    return "<media:video>";
+  }
+  return "<media:file>";
+}
+
+function buildLocalAgentMediaPayload(
+  mediaList: Array<{ path: string; contentType?: string }>,
+): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((media) => media.path);
+  const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean) as string[];
+  return {
+    MediaPath: first?.path,
+    MediaType: first?.contentType ?? undefined,
+    MediaUrl: first?.path,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+  };
+}
+
+export function registerDdchatWebhook(api: OpenClawPluginApi): void {
+  api.registerHttpRoute({
+    path: "/ddchat/webhook",
+    auth: "plugin",
+    handler: async (req, res) => {
+      try {
+        const body = await readBody(req as InboundReq);
+        const result = await processDdchatInboundWithChannelRuntime({
+          channelRuntime: api.runtime.channel,
+          cfg: api.runtime.config.loadConfig(),
+          body,
+          source: "webhook",
+          logInfo: (message) =>
+            api.runtime.logging.getChildLogger({ module: "ddchat-inbound" }).info(message),
+        });
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify(result));
+      } catch (error) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end(error instanceof Error ? error.message : "invalid request");
+      }
+      return true;
+    },
+  });
+}
+
+export async function processDdchatInboundWithChannelRuntime(params: {
+  channelRuntime: OpenClawPluginApi["runtime"]["channel"];
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>;
+  body: unknown;
+  fallbackAccountId?: string;
+  source?: "webhook" | "ws";
+  logInfo?: (message: string) => void;
+}): Promise<
+  | { ok: true; duplicate: true; messageId: string; accountId: string }
+  | { ok: true; sessionKey: string; agentId: string; deliveredCount: number; delivered: Array<{ messageId?: string; text?: string }> }
+> {
+  const body = parseBodyLike(params.body);
+  const accountId = String(body.accountId ?? params.fallbackAccountId ?? "default").trim() || "default";
+  const account = resolveDdchatAccount(params.cfg, accountId);
+  const identity = resolveInboundIdentity(body);
+
+  if (getDdchatState().dedupe.isDuplicate(account.accountId, identity.messageId)) {
+    return {
+      ok: true,
+      duplicate: true,
+      messageId: identity.messageId,
+      accountId: account.accountId,
+    };
+  }
+
+  const peer = identity.chatType === "group"
+    ? { kind: "group" as const, id: identity.groupId! }
+    : { kind: "direct" as const, id: identity.userId };
+  const route = params.channelRuntime.routing.resolveAgentRoute({
+    cfg: params.cfg,
+    channel: DDCHAT_CHANNEL_ID,
+    accountId: account.accountId,
+    peer,
+  });
+
+  const mediaList = await resolveInboundMedia({
+    channelRuntime: params.channelRuntime,
+    cfg: params.cfg,
+    files: toInboundFiles(body),
+    logInfo: params.logInfo,
+  });
+  const mediaPayload = buildLocalAgentMediaPayload(mediaList);
+  const inboundText = typeof body.text === "string" && body.text.trim()
+    ? body.text.trim()
+    : mediaList.length > 0
+      ? inferBodyFromMedia(mediaList)
+      : "";
+  if (!inboundText) {
+    throw new Error("missing text/files");
+  }
+
+  const timestamp = Date.now();
+  const from = `ddchat:${identity.userId}`;
+  const to = identity.chatType === "group" ? `group:${identity.groupId}` : `user:${identity.userId}`;
+  const ctxPayload = params.channelRuntime.reply.finalizeInboundContext({
+    Body: inboundText,
+    BodyForAgent: inboundText,
+    RawBody: inboundText,
+    CommandBody: inboundText,
+    From: from,
+    To: to,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: identity.chatType,
+    GroupSubject: identity.chatType === "group" ? identity.groupId : undefined,
+    SenderId: identity.userId,
+    MessageSid: identity.messageId,
+    Timestamp: timestamp,
+    Provider: DDCHAT_CHANNEL_ID,
+    Surface: DDCHAT_CHANNEL_ID,
+    OriginatingChannel: DDCHAT_CHANNEL_ID,
+    OriginatingTo: to,
+    CommandAuthorized: true,
+    ...mediaPayload,
+  });
+
+  const delivered: Array<{ messageId?: string; text?: string }> = [];
+  const streamId = `ddchat-stream-${identity.messageId}`;
+  let streamText = "";
+  const streamMode = account.streamingMode;
+  const emitStream = (patch: { delta?: string; done: boolean }) => {
+    getDdchatState().wsSend?.({
+      type: "stream_chunk",
+      streamId,
+      accountId: account.accountId,
+      source: params.source ?? "ws",
+      sessionKey: route.sessionKey,
+      agentId: route.agentId,
+      mode: streamMode,
+      delta: patch.delta ?? "",
+      fullText: streamText,
+      done: patch.done,
+      from: "plugin",
+      ts: Date.now(),
+    });
+  };
+
+  await params.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      deliver: async (payload: { text?: string; body?: string; mediaUrl?: string }) => {
+        const text = payload.text ?? payload.body ?? "";
+        if (!text && !payload.mediaUrl) {
+          return;
+        }
+        const outbound = {
+          type: "outbound_message",
+          channel: DDCHAT_CHANNEL_ID,
+          accountId: account.accountId,
+          targetType: identity.chatType,
+          targetId: identity.chatType === "group" ? identity.groupId : identity.userId,
+          text,
+          mediaUrl: payload.mediaUrl,
+        };
+        const sent = getDdchatState().wsSend?.(outbound) ?? false;
+        delivered.push({
+          messageId: sent ? `ddchat-out-${Date.now()}` : undefined,
+          text,
+        });
+        if (account.streaming && text) {
+          streamText += text;
+          emitStream({ delta: text, done: false });
+        }
+      },
+      onReplyStart: () => {
+        params.logInfo?.("ddchat agent reply started");
+      },
+    },
+  });
+  if (account.streaming) {
+    emitStream({ done: true });
+  }
+  return {
+    ok: true,
+    sessionKey: route.sessionKey,
+    agentId: route.agentId,
+    deliveredCount: delivered.length,
+    delivered,
+  };
+}

package/src/outbound.ts

@@ -0,0 +1,95 @@
+import { loadWebMedia } from "openclaw/plugin-sdk/media-runtime";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { getDdchatState } from "./runtime.js";
+
+function resolveMediaMaxBytes(cfg: OpenClawConfig): number | undefined {
+  const mb = cfg.agents?.defaults?.mediaMaxMb;
+  if (!mb || mb <= 0) {
+    return undefined;
+  }
+  return mb * 1024 * 1024;
+}
+
+function resolveTarget(to: string): { targetType: "group" | "direct"; targetId: string } {
+  const normalized = to.trim();
+  if (normalized.startsWith("group:")) {
+    return { targetType: "group", targetId: normalized.slice("group:".length) };
+  }
+  if (normalized.startsWith("chat:")) {
+    return { targetType: "group", targetId: normalized.slice("chat:".length) };
+  }
+  if (normalized.startsWith("user:")) {
+    return { targetType: "direct", targetId: normalized.slice("user:".length) };
+  }
+  return { targetType: "direct", targetId: normalized };
+}
+
+export const ddchatOutbound = {
+  deliveryMode: "direct",
+  textChunkLimit: 4000,
+  chunkerMode: "markdown",
+  sendText: async ({ to, text, accountId }) => {
+    const messageId = `ddchat-text-${Date.now()}`;
+    const target = resolveTarget(to);
+    const payload = {
+      type: "outbound_message",
+      from: "plugin",
+      channel: DDCHAT_CHANNEL_ID,
+      accountId,
+      messageId,
+      targetType: target.targetType,
+      targetId: target.targetId,
+      text,
+    };
+    const sent = getDdchatState().wsSend?.(payload) ?? false;
+    return {
+      messageId,
+      to,
+      channel: DDCHAT_CHANNEL_ID,
+      text,
+      transport: sent ? "ws" : "mock",
+    };
+  },
+  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+    const messageId = `ddchat-media-${Date.now()}`;
+    const target = resolveTarget(to);
+    let mediaBase64: string | undefined;
+    let mediaType: string | undefined;
+    let mediaName: string | undefined;
+    try {
+      const media = await loadWebMedia(mediaUrl, {
+        maxBytes: resolveMediaMaxBytes(cfg),
+      });
+      mediaBase64 = media.buffer.toString("base64");
+      mediaType = media.contentType;
+      mediaName = media.fileName;
+    } catch {
+      // Keep URL-only fallback for remote/local unsupported cases.
+    }
+    const payload = {
+      type: "outbound_message",
+      channel: DDCHAT_CHANNEL_ID,
+      accountId,
+      messageId,
+      targetType: target.targetType,
+      targetId: target.targetId,
+      text,
+      mediaUrl,
+      mediaBase64,
+      mediaType,
+      mediaName,
+    };
+    const sent = getDdchatState().wsSend?.(payload) ?? false;
+    return {
+      messageId,
+      to,
+      channel: DDCHAT_CHANNEL_ID,
+      text,
+      mediaUrl,
+      mediaType,
+      mediaName,
+      transport: sent ? "ws" : "mock",
+    };
+  },
+};

package/src/pairing.ts

@@ -0,0 +1,9 @@
+import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
+
+export const ddchatPairing = {
+  idLabel: "ddchatUserId",
+  normalizeAllowEntry: createPairingPrefixStripper(/^(ddchat|user):/i),
+  notifyApproval: async ({ runtime, id }) => {
+    runtime?.log?.(`[ddchat] pairing approved for ${id}`);
+  },
+};

package/src/runtime.ts

@@ -0,0 +1,24 @@
+import { DdchatDedupeStore } from "./dedupe.js";
+
+export type DdchatPluginRuntimeState = {
+  dedupe: DdchatDedupeStore;
+  wsSend?: (payload: Record<string, unknown>) => boolean;
+  wsConnected: boolean;
+};
+
+const state: DdchatPluginRuntimeState = {
+  dedupe: new DdchatDedupeStore(),
+  wsConnected: false,
+};
+
+export function getDdchatState(): DdchatPluginRuntimeState {
+  return state;
+}
+
+export function setDdchatWsRuntime(params: {
+  send?: (payload: Record<string, unknown>) => boolean;
+  connected: boolean;
+}): void {
+  state.wsSend = params.send;
+  state.wsConnected = params.connected;
+}

package/src/session.ts

@@ -0,0 +1,19 @@
+export function buildDdchatSessionKey(params: {
+  peerKind: "direct" | "group";
+  peerId: string;
+  senderId?: string;
+  threadId?: string | null;
+}): string {
+  const base =
+    params.peerKind === "group"
+      ? `ddchat:group:${params.peerId}`
+      : `ddchat:direct:${params.peerId}`;
+  const thread = params.threadId?.trim();
+  if (!thread) {
+    return base;
+  }
+  if (params.peerKind === "group" && params.senderId) {
+    return `${base}:thread:${thread}:sender:${params.senderId}`;
+  }
+  return `${base}:thread:${thread}`;
+}

package/src/types.ts

@@ -0,0 +1,126 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { DDCHAT_CHANNEL_ID, DDCHAT_DEFAULT_ACCOUNT_ID } from "./constants.js";
+
+export type DdchatStreamingMode = "chunk" | "token";
+export type DdchatConnectionMode = "websocket" | "webhook";
+export type DdchatPolicy = "open" | "pairing" | "allowlist";
+
+export type DdchatResolvedAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  token?: string;
+  wsUrl?: string;
+  webhookPath?: string;
+  webhookPort?: number;
+  connectionMode: DdchatConnectionMode;
+  dmPolicy: DdchatPolicy;
+  groupPolicy: "open" | "allowlist" | "disabled";
+  requireMention: boolean;
+  streaming: boolean;
+  streamingMode: DdchatStreamingMode;
+  allowFrom: string[];
+  groupAllowFrom: string[];
+  heartbeatSec: number;
+};
+
+type DdchatAccountConfig = {
+  enabled?: boolean;
+  token?: string;
+  wsUrl?: string;
+  webhookPath?: string;
+  webhookPort?: number;
+  connectionMode?: DdchatConnectionMode;
+  dmPolicy?: DdchatPolicy;
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  requireMention?: boolean;
+  streaming?: boolean;
+  streamingMode?: DdchatStreamingMode;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  heartbeatSec?: number;
+};
+
+type DdchatChannelConfig = DdchatAccountConfig & {
+  defaultAccount?: string;
+  accounts?: Record<string, DdchatAccountConfig | undefined>;
+};
+
+function toStringList(input: Array<string | number> | undefined): string[] {
+  if (!input) {
+    return [];
+  }
+  return input.map((entry) => String(entry).trim()).filter(Boolean);
+}
+
+function normalizeConnectionMode(mode: string | undefined): DdchatConnectionMode {
+  return mode === "webhook" ? "webhook" : "websocket";
+}
+
+function normalizeStreamingMode(mode: string | undefined): DdchatStreamingMode {
+  return mode === "token" ? "token" : "chunk";
+}
+
+function readChannelConfig(cfg: OpenClawConfig): DdchatChannelConfig {
+  return ((cfg.channels as Record<string, unknown> | undefined)?.[DDCHAT_CHANNEL_ID] ?? {}) as DdchatChannelConfig;
+}
+
+function mergeAccountConfig(params: {
+  root: DdchatChannelConfig;
+  account?: DdchatAccountConfig;
+}): DdchatAccountConfig {
+  const { root, account } = params;
+  return {
+    ...root,
+    ...account,
+  };
+}
+
+export function listDdchatAccountIds(cfg: OpenClawConfig): string[] {
+  const channelCfg = readChannelConfig(cfg);
+  const keys = Object.keys(channelCfg.accounts ?? {}).filter((key) => key.trim().length > 0);
+  return keys.length > 0 ? keys : [DDCHAT_DEFAULT_ACCOUNT_ID];
+}
+
+export function resolveDefaultDdchatAccountId(cfg: OpenClawConfig): string {
+  const channelCfg = readChannelConfig(cfg);
+  const ids = listDdchatAccountIds(cfg);
+  const configured = channelCfg.defaultAccount?.trim();
+  return configured && ids.includes(configured) ? configured : ids[0];
+}
+
+export function resolveDdchatAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): DdchatResolvedAccount {
+  const channelCfg = readChannelConfig(cfg);
+  const resolvedAccountId = accountId?.trim() || resolveDefaultDdchatAccountId(cfg);
+  const named = channelCfg.accounts?.[resolvedAccountId];
+  const merged = mergeAccountConfig({ root: channelCfg, account: named });
+  const token = typeof merged.token === "string" ? merged.token.trim() : "";
+  const wsUrl = typeof merged.wsUrl === "string" ? merged.wsUrl.trim() : "";
+  return {
+    accountId: resolvedAccountId,
+    enabled: merged.enabled !== false,
+    configured: Boolean(token),
+    token: token || undefined,
+    wsUrl: wsUrl || undefined,
+    webhookPath:
+      typeof merged.webhookPath === "string" && merged.webhookPath.trim()
+        ? merged.webhookPath.trim()
+        : "/ddchat/webhook",
+    webhookPort:
+      typeof merged.webhookPort === "number" && Number.isFinite(merged.webhookPort)
+        ? merged.webhookPort
+        : 3010,
+    connectionMode: normalizeConnectionMode(merged.connectionMode),
+    dmPolicy: merged.dmPolicy ?? "pairing",
+    groupPolicy: merged.groupPolicy ?? "allowlist",
+    requireMention: merged.requireMention === true,
+    streaming: merged.streaming !== false,
+    streamingMode: normalizeStreamingMode(merged.streamingMode),
+    allowFrom: toStringList(merged.allowFrom),
+    groupAllowFrom: toStringList(merged.groupAllowFrom),
+    heartbeatSec: Math.max(15, Number(merged.heartbeatSec ?? 60) || 60),
+  };
+}

package/task/BLOCKERS.md

@@ -0,0 +1,3 @@
+# BLOCKERS
+
+- None currently.

package/task/DOING.md

@@ -0,0 +1,3 @@
+# DOING
+
+- [ ] Implement websocket-first inbound and chunk streaming for multi-account `ddchat`

package/task/DONE.md

@@ -0,0 +1,8 @@
+# DONE
+
+- [x] Created `ddchat/task` workflow files (`README/TODO/DOING/DONE/BLOCKERS`)
+  - Date: 2026-04-01
+  - Verification: files exist under `ddchat/task/`
+- [x] Initialized DDChat plugin skeleton and websocket-first runtime scaffold
+  - Date: 2026-04-01
+  - Verification: `ddchat/package.json`, `ddchat/openclaw.plugin.json`, and `ddchat/src/*` core files created

package/task/README.md

@@ -0,0 +1,17 @@
+# DDChat Task Records
+
+This directory tracks development progress for the `ddchat` plugin.
+
+## Files
+
+- `TODO.md`: all pending tasks
+- `DOING.md`: the single task currently in progress
+- `DONE.md`: completed tasks with verification notes
+- `BLOCKERS.md`: blockers, decisions, and risks
+
+## Workflow
+
+1. Move one item from `TODO.md` to `DOING.md` before coding.
+2. When finished, move it to `DONE.md` with date and verification notes.
+3. If blocked, add details to `BLOCKERS.md` and stop starting new work.
+4. Keep `DOING.md` to one active task only.