happy-imou-cloud 2.1.26 → 2.1.28

package/dist/{api-hgzFUi7o.cjs → api-ChV_1TP7.cjs}

@@ -8,6 +8,7 @@ var os = require('node:os');
 var path = require('node:path');
 var z = require('zod');
 var node_events = require('node:events');
+var promises = require('node:fs/promises');
 var socket_ioClient = require('socket.io-client');
 var node_crypto = require('node:crypto');
 var tweetnacl = require('tweetnacl');
@@ -15,7 +16,6 @@ var fs$2 = require('fs/promises');
 var crypto = require('crypto');
 var path$1 = require('path');
 var node_child_process = require('node:child_process');
-var promises = require('node:fs/promises');
 var expoServerSdk = require('expo-server-sdk');
 
 function _interopNamespaceDefault(e) {
@@ -38,7 +38,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "happy-imou-cloud";
-var version = "2.1.26";
+var version = "2.1.28";
 var description = "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI";
 var author = "long.zhu";
 var license = "MIT";
@@ -310,6 +310,39 @@ function getSessionLogPath() {
   const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
   return path.join(configuration.logsDir, filename);
 }
+function isErrorLike(value) {
+  return value !== null && typeof value === "object" && ("stack" in value || "message" in value);
+}
+function formatLogArgument(value, pretty = false) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.stack || value.message;
+  }
+  if (isErrorLike(value)) {
+    if (typeof value.stack === "string" && value.stack.length > 0) {
+      return value.stack;
+    }
+    if (typeof value.message === "string" && value.message.length > 0) {
+      return value.message;
+    }
+  }
+  try {
+    const serialized = JSON.stringify(value, null, pretty ? 2 : void 0);
+    return serialized === void 0 ? String(value) : serialized;
+  } catch {
+    if (isErrorLike(value)) {
+      if (typeof value.stack === "string" && value.stack.length > 0) {
+        return value.stack;
+      }
+      if (typeof value.message === "string" && value.message.length > 0) {
+        return value.message;
+      }
+    }
+    return String(value);
+  }
+}
 class Logger {
   constructor(logFilePath = getSessionLogPath()) {
     this.logFilePath = logFilePath;
@@ -331,12 +364,18 @@ class Logger {
     if (!process.env.DEBUG) {
       this.debug(`In production, skipping message inspection`);
     }
-    const truncateStrings = (obj) => {
+    const truncateStrings = (obj, seen = /* @__PURE__ */ new WeakSet()) => {
       if (typeof obj === "string") {
         return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
       }
+      if (obj && typeof obj === "object") {
+        if (seen.has(obj)) {
+          return "[Circular]";
+        }
+        seen.add(obj);
+      }
       if (Array.isArray(obj)) {
-        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        const truncatedArray = obj.map((item) => truncateStrings(item, seen)).slice(0, maxArrayLength);
         if (obj.length > maxArrayLength) {
           truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
         }
@@ -348,14 +387,14 @@ class Logger {
           if (key === "usage") {
             continue;
           }
-          result[key] = truncateStrings(value);
+          result[key] = truncateStrings(value, seen);
         }
         return result;
       }
       return obj;
     };
     const truncatedObject = truncateStrings(object);
-    const json = JSON.stringify(truncatedObject, null, 2);
+    const json = formatLogArgument(truncatedObject, true);
     this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
   }
   info(message, ...args) {
@@ -409,9 +448,7 @@ class Logger {
         body: JSON.stringify({
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           level,
-          message: `${message} ${args.map(
-            (a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)
-          ).join(" ")}`,
+          message: `${message} ${args.map((arg) => formatLogArgument(arg, true)).join(" ")}`,
           source: "cli",
           platform: process.platform
         })
@@ -420,9 +457,7 @@ class Logger {
     }
   }
   logToFile(prefix, message, ...args) {
-    const logLine = `${prefix} ${message} ${args.map(
-      (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
-    ).join(" ")}
+    const logLine = `${prefix} ${message} ${args.map((arg) => formatLogArgument(arg)).join(" ")}
 `;
     if (this.dangerouslyUnencryptedServerLoggingUrl) {
       let level = "info";
@@ -1559,6 +1594,813 @@ const AgentMessageSchema = z.z.object({
 });
 const MessageContentSchema = z.z.union([UserMessageSchema, AgentMessageSchema]);
 
+const HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION = "1.7.3-local-repo-v1";
+const TaskStatusSchema = z.z.enum([
+  "draft",
+  "ready",
+  "active",
+  "waiting_review",
+  "waiting_decision",
+  "blocked",
+  "waiting_close",
+  "done",
+  "terminated"
+]);
+const AdviceRouteValueSchema = z.z.union([
+  z.z.literal("gm"),
+  z.z.literal("lead"),
+  z.z.literal("user")
+]);
+const AdviceRouteSchema = z.z.union([
+  AdviceRouteValueSchema,
+  z.z.null()
+]);
+const GoalSchema = z.z.object({
+  summary: z.z.string(),
+  successCriteria: z.z.array(z.z.string()),
+  boundaryNotes: z.z.array(z.z.string()),
+  strategyNotes: z.z.array(z.z.string()),
+  roadmapNotes: z.z.array(z.z.string()),
+  decisions: z.z.array(z.z.string()),
+  approvedAt: z.z.number().nullable(),
+  approvedBy: z.z.string().nullable(),
+  updatedAt: z.z.number()
+});
+const TaskUpdatePayloadSchema = z.z.object({
+  taskId: z.z.string().min(1),
+  status: TaskStatusSchema,
+  summary: z.z.string().optional(),
+  resultSummary: z.z.string().optional(),
+  reviewSummary: z.z.string().nullable().optional(),
+  blocker: z.z.string().nullable().optional(),
+  decisionNeeded: z.z.string().nullable().optional(),
+  adviceRoute: AdviceRouteSchema.optional(),
+  adviceSummary: z.z.string().nullable().optional(),
+  assetCaptureStatus: z.z.enum([
+    "linked_existing_asset",
+    "new_asset_candidate",
+    "no_asset_needed",
+    "asset_capture_failed"
+  ]).nullable().optional(),
+  assetCaptureSummary: z.z.string().nullable().optional(),
+  assetReference: z.z.string().nullable().optional(),
+  closedAt: z.z.number().nullable().optional(),
+  lastUpdatedBy: z.z.string().nullable().optional()
+});
+const BaseRequestSchema = z.z.object({
+  schemaVersion: z.z.literal(HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION),
+  requestId: z.z.string().min(1),
+  requestState: z.z.enum(["pending", "applied", "recovery_required"]),
+  createdAt: z.z.number().int(),
+  createdBy: z.z.literal("app"),
+  organizationSlug: z.z.string().min(1),
+  processedAt: z.z.number().nullable(),
+  resultMessage: z.z.string().nullable()
+});
+const ReplaceGoalRequestSchema = BaseRequestSchema.extend({
+  requestType: z.z.literal("replace_goal"),
+  goal: GoalSchema,
+  expectedRevision: z.z.number().nullable()
+});
+const CreateTaskRequestSchema = BaseRequestSchema.extend({
+  requestType: z.z.literal("create_task"),
+  ownerAgentId: z.z.string().min(1),
+  ownerName: z.z.string().min(1),
+  ownerSessionId: z.z.string().nullable(),
+  title: z.z.string().min(1),
+  path: z.z.string(),
+  successCriteria: z.z.array(z.z.string()),
+  summary: z.z.string().nullable()
+});
+const UpdateTaskRequestSchema = BaseRequestSchema.extend({
+  requestType: z.z.literal("update_task"),
+  taskId: z.z.string().min(1),
+  expectedRevision: z.z.number().nullable(),
+  nextState: TaskUpdatePayloadSchema
+});
+const RequestSchema = z.z.discriminatedUnion("requestType", [
+  ReplaceGoalRequestSchema,
+  CreateTaskRequestSchema,
+  UpdateTaskRequestSchema
+]);
+const RevisionEnvelopeSchema = (value) => z.z.object({
+  schemaVersion: z.z.literal(HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION),
+  revision: z.z.number().int().nonnegative(),
+  updatedAt: z.z.number().int(),
+  updatedBy: z.z.string().nullable(),
+  value
+});
+const PositionValueSchema = z.z.object({
+  positionId: z.z.string(),
+  slug: z.z.string(),
+  label: z.z.string(),
+  role: z.z.string(),
+  agentId: z.z.string(),
+  agentName: z.z.string(),
+  supervisorAgentId: z.z.string().nullable(),
+  responsibilityIds: z.z.array(z.z.string()),
+  occupancyStatus: z.z.enum(["occupied", "vacancy"]),
+  truthPath: z.z.string(),
+  createdAt: z.z.number(),
+  updatedAt: z.z.number()
+});
+const ResponsibilityValueSchema = z.z.object({
+  responsibilityId: z.z.string(),
+  title: z.z.string(),
+  summary: z.z.string().nullable(),
+  positionId: z.z.string(),
+  participantType: z.z.enum(["agent", "vacancy"]),
+  status: z.z.enum(["vacancy", "assigned", "in_progress"]),
+  memberAgentId: z.z.string().nullable(),
+  memberName: z.z.string().nullable(),
+  activeTaskId: z.z.string().nullable(),
+  createdAt: z.z.number(),
+  updatedAt: z.z.number()
+});
+const TaskValueSchema = z.z.object({
+  taskId: z.z.string(),
+  slug: z.z.string(),
+  title: z.z.string(),
+  ownerAgentId: z.z.string(),
+  ownerName: z.z.string(),
+  ownerSessionId: z.z.string().nullable(),
+  responsibilityId: z.z.string().nullable(),
+  responsibilityLabel: z.z.string().nullable(),
+  activeOwnerAgentId: z.z.string().nullable(),
+  hasActiveOwner: z.z.boolean(),
+  path: z.z.string(),
+  portablePath: z.z.string().nullable(),
+  successCriteria: z.z.array(z.z.string()),
+  status: TaskStatusSchema,
+  summary: z.z.string(),
+  resultSummary: z.z.string(),
+  reviewSummary: z.z.string().nullable(),
+  blocker: z.z.string().nullable(),
+  decisionNeeded: z.z.string().nullable(),
+  adviceRoute: AdviceRouteSchema,
+  adviceSummary: z.z.string().nullable(),
+  assetCaptureStatus: z.z.enum([
+    "linked_existing_asset",
+    "new_asset_candidate",
+    "no_asset_needed",
+    "asset_capture_failed"
+  ]).nullable(),
+  assetCaptureSummary: z.z.string().nullable(),
+  assetReference: z.z.string().nullable(),
+  closedAt: z.z.number().nullable(),
+  conversationSessionId: z.z.string().nullable(),
+  createdAt: z.z.number(),
+  updatedAt: z.z.number(),
+  lastUpdatedBy: z.z.string().nullable()
+});
+const WorkflowValueSchema = z.z.object({
+  taskId: z.z.string(),
+  status: TaskStatusSchema,
+  summary: z.z.string(),
+  blocker: z.z.string().nullable(),
+  decisionNeeded: z.z.string().nullable(),
+  adviceRoute: AdviceRouteSchema,
+  adviceSummary: z.z.string().nullable(),
+  lastRequestId: z.z.string().nullable(),
+  updatedAt: z.z.number(),
+  updatedBy: z.z.string().nullable()
+});
+const ResultValueSchema = z.z.object({
+  taskId: z.z.string(),
+  resultSummary: z.z.string(),
+  reviewSummary: z.z.string().nullable(),
+  assetCaptureStatus: z.z.enum([
+    "linked_existing_asset",
+    "new_asset_candidate",
+    "no_asset_needed",
+    "asset_capture_failed"
+  ]).nullable(),
+  assetCaptureSummary: z.z.string().nullable(),
+  assetReference: z.z.string().nullable(),
+  closedAt: z.z.number().nullable(),
+  updatedAt: z.z.number(),
+  updatedBy: z.z.string().nullable()
+});
+const LogEntrySchema = z.z.object({
+  id: z.z.string(),
+  eventType: z.z.enum(["snapshot_bootstrap", "request_applied", "turn_report"]),
+  message: z.z.string(),
+  summary: z.z.string().nullable(),
+  createdAt: z.z.number(),
+  actor: z.z.string().nullable()
+});
+const LogValueSchema = z.z.object({
+  taskId: z.z.string(),
+  entries: z.z.array(LogEntrySchema)
+});
+const GoalEnvelopeSchema = RevisionEnvelopeSchema(GoalSchema);
+const PositionEnvelopeSchema = RevisionEnvelopeSchema(PositionValueSchema);
+const ResponsibilityEnvelopeSchema = RevisionEnvelopeSchema(z.z.array(ResponsibilityValueSchema));
+const TaskEnvelopeSchema = RevisionEnvelopeSchema(TaskValueSchema);
+const WorkflowEnvelopeSchema = RevisionEnvelopeSchema(WorkflowValueSchema);
+const ResultEnvelopeSchema = RevisionEnvelopeSchema(ResultValueSchema);
+const LogEnvelopeSchema = RevisionEnvelopeSchema(LogValueSchema);
+function normalizePortablePath(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\/$/, "");
+}
+function normalizeAdviceRoute(value) {
+  return value === "gm" || value === "lead" || value === "user" ? value : null;
+}
+function buildResponsibilityId(slug) {
+  return `responsibility-${slug}`;
+}
+function buildPositionId(slug) {
+  return `position-${slug}`;
+}
+function toTaskSlug(taskId, title) {
+  const slug = title.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${taskId.toLowerCase()}-${slug || "task"}`;
+}
+function buildTaskLogEntry(eventType, message, summary, actor, createdAt) {
+  return {
+    id: `${eventType}-${createdAt.toString(36)}`,
+    eventType,
+    message,
+    summary,
+    createdAt,
+    actor
+  };
+}
+async function ensureDir(dirPath) {
+  await promises.mkdir(dirPath, { recursive: true });
+}
+async function readJson(filePath) {
+  try {
+    const text = await promises.readFile(filePath, "utf8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await promises.writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
+}
+async function readEnvelope(filePath, schema) {
+  const value = await readJson(filePath);
+  const parsed = schema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+async function writeEnvelope(filePath, value) {
+  await writeJson(filePath, value);
+}
+function buildRequestFilePath(rootPath, requestId) {
+  return path.join(rootPath, "requests", `${requestId}.json`);
+}
+function buildTaskRoot(rootPath, taskId) {
+  return path.join(rootPath, "tasks", taskId);
+}
+async function loadTaskEnvelope(rootPath, taskId) {
+  const taskRoot = buildTaskRoot(rootPath, taskId);
+  const task = await readEnvelope(path.join(taskRoot, "TASK.json"), TaskEnvelopeSchema);
+  if (!task) {
+    return null;
+  }
+  const workflow = await readEnvelope(path.join(taskRoot, "WORKFLOW.json"), WorkflowEnvelopeSchema);
+  const result = await readEnvelope(path.join(taskRoot, "RESULT.json"), ResultEnvelopeSchema);
+  const log = await readEnvelope(path.join(taskRoot, "LOG.json"), LogEnvelopeSchema);
+  return { task, workflow, result, log };
+}
+async function listTaskIds(rootPath) {
+  try {
+    const entries = await promises.readdir(path.join(rootPath, "tasks"), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function nextTaskId(rootPath) {
+  const taskIds = await listTaskIds(rootPath);
+  const nextNumber = taskIds.map((taskId) => Number.parseInt(taskId.replace(/^T-/, ""), 10)).filter((value) => Number.isFinite(value)).reduce((max, value) => Math.max(max, value), 0) + 1;
+  return `T-${String(nextNumber).padStart(3, "0")}`;
+}
+async function listPositionEnvelopes(rootPath) {
+  try {
+    const entries = await promises.readdir(path.join(rootPath, "positions"), { withFileTypes: true });
+    const envelopes = await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readEnvelope(path.join(rootPath, "positions", entry.name), PositionEnvelopeSchema)));
+    return envelopes.filter((entry) => entry !== null);
+  } catch {
+    return [];
+  }
+}
+async function readResponsibilities(rootPath) {
+  return await readEnvelope(path.join(rootPath, "RESPONSIBILITIES.json"), ResponsibilityEnvelopeSchema);
+}
+function mergeTaskEnvelope(taskBundle) {
+  const { task, workflow, result } = taskBundle;
+  return {
+    ...task.value,
+    status: workflow?.value.status ?? task.value.status,
+    summary: workflow?.value.summary ?? task.value.summary,
+    blocker: workflow?.value.blocker ?? task.value.blocker,
+    decisionNeeded: workflow?.value.decisionNeeded ?? task.value.decisionNeeded,
+    adviceRoute: workflow?.value.adviceRoute ?? task.value.adviceRoute,
+    adviceSummary: workflow?.value.adviceSummary ?? task.value.adviceSummary,
+    resultSummary: result?.value.resultSummary ?? task.value.resultSummary,
+    reviewSummary: result?.value.reviewSummary ?? task.value.reviewSummary,
+    assetCaptureStatus: result?.value.assetCaptureStatus ?? task.value.assetCaptureStatus,
+    assetCaptureSummary: result?.value.assetCaptureSummary ?? task.value.assetCaptureSummary,
+    assetReference: result?.value.assetReference ?? task.value.assetReference,
+    closedAt: result?.value.closedAt ?? task.value.closedAt,
+    updatedAt: Math.max(task.value.updatedAt, workflow?.value.updatedAt ?? 0, result?.value.updatedAt ?? 0)
+  };
+}
+async function rebuildResponsibilities(rootPath) {
+  const positions = await listPositionEnvelopes(rootPath);
+  const tasks = await Promise.all((await listTaskIds(rootPath)).map(async (taskId) => {
+    const bundle = await loadTaskEnvelope(rootPath, taskId);
+    return bundle ? mergeTaskEnvelope(bundle) : null;
+  }));
+  const normalizedTasks = tasks.filter((task) => task !== null);
+  const existing = await readResponsibilities(rootPath);
+  const previousRevision = existing?.revision ?? 0;
+  const responsibilities = positions.map((position) => {
+    const activeTask = normalizedTasks.filter((task) => task.ownerAgentId === position.value.agentId && task.status !== "done" && task.status !== "terminated").sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
+    return {
+      responsibilityId: buildResponsibilityId(position.value.slug),
+      title: `${position.value.agentName} responsibility`,
+      summary: activeTask?.summary ?? null,
+      positionId: buildPositionId(position.value.slug),
+      participantType: "agent",
+      status: activeTask ? "in_progress" : "assigned",
+      memberAgentId: position.value.agentId,
+      memberName: position.value.agentName,
+      activeTaskId: activeTask?.taskId ?? null,
+      createdAt: position.value.createdAt,
+      updatedAt: Math.max(position.value.updatedAt, activeTask?.updatedAt ?? 0)
+    };
+  });
+  await writeEnvelope(path.join(rootPath, "RESPONSIBILITIES.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: previousRevision + 1,
+    updatedAt: Math.max(...responsibilities.map((item) => item.updatedAt), 0),
+    updatedBy: "cli-writer",
+    value: responsibilities
+  });
+}
+async function updateRequestRecord(rootPath, request, patch) {
+  const nextRequest = {
+    ...request,
+    ...patch
+  };
+  await writeJson(buildRequestFilePath(rootPath, request.requestId), nextRequest);
+  return nextRequest;
+}
+async function applyReplaceGoalRequest(rootPath, request) {
+  const goalPath = path.join(rootPath, "GOAL.json");
+  const goalEnvelope = await readEnvelope(goalPath, GoalEnvelopeSchema);
+  if (!goalEnvelope) {
+    await updateRequestRecord(rootPath, request, {
+      requestState: "recovery_required",
+      processedAt: Date.now(),
+      resultMessage: "GOAL.json is missing or invalid"
+    });
+    return {
+      outcome: "recovery_required",
+      requestId: request.requestId,
+      taskId: null,
+      message: "GOAL.json is missing or invalid"
+    };
+  }
+  if (request.expectedRevision !== null && goalEnvelope.revision !== request.expectedRevision) {
+    const message = `Goal revision mismatch: expected ${request.expectedRevision}, got ${goalEnvelope.revision}`;
+    await updateRequestRecord(rootPath, request, {
+      requestState: "recovery_required",
+      processedAt: Date.now(),
+      resultMessage: message
+    });
+    return {
+      outcome: "recovery_required",
+      requestId: request.requestId,
+      taskId: null,
+      message
+    };
+  }
+  await writeEnvelope(goalPath, {
+    ...goalEnvelope,
+    revision: goalEnvelope.revision + 1,
+    updatedAt: request.goal.updatedAt,
+    updatedBy: request.goal.approvedBy ?? "app",
+    value: request.goal
+  });
+  await updateRequestRecord(rootPath, request, {
+    requestState: "applied",
+    processedAt: Date.now(),
+    resultMessage: "goal updated"
+  });
+  return {
+    outcome: "applied",
+    requestId: request.requestId,
+    taskId: null,
+    message: "goal updated"
+  };
+}
+async function applyCreateTaskRequest(rootPath, request) {
+  const taskId = await nextTaskId(rootPath);
+  const taskRoot = buildTaskRoot(rootPath, taskId);
+  const createdAt = Date.now();
+  const title = request.title.trim();
+  const position = (await listPositionEnvelopes(rootPath)).find((entry) => entry.value.agentId === request.ownerAgentId) ?? null;
+  const taskValue = {
+    taskId,
+    slug: toTaskSlug(taskId, title),
+    title,
+    ownerAgentId: request.ownerAgentId,
+    ownerName: request.ownerName,
+    ownerSessionId: request.ownerSessionId,
+    responsibilityId: position ? buildResponsibilityId(position.value.slug) : null,
+    responsibilityLabel: position ? `${position.value.agentName} responsibility` : `${request.ownerName} responsibility`,
+    activeOwnerAgentId: null,
+    hasActiveOwner: false,
+    path: request.path,
+    portablePath: normalizePortablePath(request.path),
+    successCriteria: request.successCriteria,
+    status: "ready",
+    summary: request.summary ?? "Task created and ready for execution.",
+    resultSummary: "",
+    reviewSummary: null,
+    blocker: null,
+    decisionNeeded: null,
+    adviceRoute: null,
+    adviceSummary: null,
+    assetCaptureStatus: null,
+    assetCaptureSummary: null,
+    assetReference: null,
+    closedAt: null,
+    conversationSessionId: request.ownerSessionId,
+    createdAt,
+    updatedAt: createdAt,
+    lastUpdatedBy: request.ownerAgentId
+  };
+  await ensureDir(taskRoot);
+  await writeEnvelope(path.join(taskRoot, "TASK.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: 1,
+    updatedAt: createdAt,
+    updatedBy: request.ownerAgentId,
+    value: taskValue
+  });
+  await writeEnvelope(path.join(taskRoot, "WORKFLOW.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: 1,
+    updatedAt: createdAt,
+    updatedBy: request.ownerAgentId,
+    value: {
+      taskId,
+      status: "ready",
+      summary: taskValue.summary,
+      blocker: null,
+      decisionNeeded: null,
+      adviceRoute: null,
+      adviceSummary: null,
+      lastRequestId: request.requestId,
+      updatedAt: createdAt,
+      updatedBy: request.ownerAgentId
+    }
+  });
+  await writeEnvelope(path.join(taskRoot, "RESULT.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: 1,
+    updatedAt: createdAt,
+    updatedBy: request.ownerAgentId,
+    value: {
+      taskId,
+      resultSummary: "",
+      reviewSummary: null,
+      assetCaptureStatus: null,
+      assetCaptureSummary: null,
+      assetReference: null,
+      closedAt: null,
+      updatedAt: createdAt,
+      updatedBy: request.ownerAgentId
+    }
+  });
+  await writeEnvelope(path.join(taskRoot, "LOG.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: 1,
+    updatedAt: createdAt,
+    updatedBy: request.ownerAgentId,
+    value: {
+      taskId,
+      entries: [
+        buildTaskLogEntry("request_applied", `Created task ${taskId}`, taskValue.summary, request.ownerAgentId, createdAt)
+      ]
+    }
+  });
+  await rebuildResponsibilities(rootPath);
+  await updateRequestRecord(rootPath, request, {
+    requestState: "applied",
+    processedAt: Date.now(),
+    resultMessage: `created ${taskId}`
+  });
+  return {
+    outcome: "applied",
+    requestId: request.requestId,
+    taskId,
+    message: `created ${taskId}`
+  };
+}
+async function applyUpdateTaskRequest(rootPath, request) {
+  const bundle = await loadTaskEnvelope(rootPath, request.taskId);
+  if (!bundle) {
+    const message = `Task ${request.taskId} not found`;
+    await updateRequestRecord(rootPath, request, {
+      requestState: "recovery_required",
+      processedAt: Date.now(),
+      resultMessage: message
+    });
+    return {
+      outcome: "recovery_required",
+      requestId: request.requestId,
+      taskId: request.taskId,
+      message
+    };
+  }
+  if (request.expectedRevision !== null && bundle.task.revision !== request.expectedRevision) {
+    const message = `Task revision mismatch: expected ${request.expectedRevision}, got ${bundle.task.revision}`;
+    await updateRequestRecord(rootPath, request, {
+      requestState: "recovery_required",
+      processedAt: Date.now(),
+      resultMessage: message
+    });
+    return {
+      outcome: "recovery_required",
+      requestId: request.requestId,
+      taskId: request.taskId,
+      message
+    };
+  }
+  const now = Date.now();
+  const nextAdviceRoute = request.nextState.adviceRoute === void 0 ? bundle.task.value.adviceRoute : normalizeAdviceRoute(request.nextState.adviceRoute);
+  const nextTaskValue = {
+    ...bundle.task.value,
+    status: request.nextState.status,
+    summary: request.nextState.summary ?? bundle.task.value.summary,
+    resultSummary: request.nextState.resultSummary ?? bundle.task.value.resultSummary,
+    reviewSummary: request.nextState.reviewSummary === void 0 ? bundle.task.value.reviewSummary : request.nextState.reviewSummary,
+    blocker: request.nextState.blocker === void 0 ? bundle.task.value.blocker : request.nextState.blocker,
+    decisionNeeded: request.nextState.decisionNeeded === void 0 ? bundle.task.value.decisionNeeded : request.nextState.decisionNeeded,
+    adviceRoute: nextAdviceRoute,
+    adviceSummary: request.nextState.adviceSummary === void 0 ? bundle.task.value.adviceSummary : request.nextState.adviceSummary,
+    assetCaptureStatus: request.nextState.assetCaptureStatus === void 0 ? bundle.task.value.assetCaptureStatus : request.nextState.assetCaptureStatus,
+    assetCaptureSummary: request.nextState.assetCaptureSummary === void 0 ? bundle.task.value.assetCaptureSummary : request.nextState.assetCaptureSummary,
+    assetReference: request.nextState.assetReference === void 0 ? bundle.task.value.assetReference : request.nextState.assetReference,
+    closedAt: request.nextState.closedAt === void 0 ? bundle.task.value.closedAt : request.nextState.closedAt,
+    updatedAt: now,
+    lastUpdatedBy: request.nextState.lastUpdatedBy ?? bundle.task.value.lastUpdatedBy
+  };
+  const nextWorkflowValue = {
+    taskId: request.taskId,
+    status: nextTaskValue.status,
+    summary: nextTaskValue.summary,
+    blocker: nextTaskValue.blocker,
+    decisionNeeded: nextTaskValue.decisionNeeded,
+    adviceRoute: nextAdviceRoute,
+    adviceSummary: nextTaskValue.adviceSummary,
+    lastRequestId: request.requestId,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy
+  };
+  const nextResultValue = {
+    taskId: request.taskId,
+    resultSummary: nextTaskValue.resultSummary,
+    reviewSummary: nextTaskValue.reviewSummary,
+    assetCaptureStatus: nextTaskValue.assetCaptureStatus,
+    assetCaptureSummary: nextTaskValue.assetCaptureSummary,
+    assetReference: nextTaskValue.assetReference,
+    closedAt: nextTaskValue.closedAt,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy
+  };
+  const nextLogValue = {
+    taskId: request.taskId,
+    entries: [
+      ...bundle.log?.value.entries ?? [],
+      buildTaskLogEntry(
+        "request_applied",
+        `Applied ${request.nextState.status} via ${request.requestId}`,
+        nextTaskValue.summary,
+        nextTaskValue.lastUpdatedBy,
+        now
+      )
+    ]
+  };
+  const taskRoot = buildTaskRoot(rootPath, request.taskId);
+  await writeEnvelope(path.join(taskRoot, "TASK.json"), {
+    ...bundle.task,
+    revision: bundle.task.revision + 1,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy,
+    value: nextTaskValue
+  });
+  await writeEnvelope(path.join(taskRoot, "WORKFLOW.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.workflow?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy,
+    value: nextWorkflowValue
+  });
+  await writeEnvelope(path.join(taskRoot, "RESULT.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.result?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy,
+    value: nextResultValue
+  });
+  await writeEnvelope(path.join(taskRoot, "LOG.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.log?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: nextTaskValue.lastUpdatedBy,
+    value: nextLogValue
+  });
+  await rebuildResponsibilities(rootPath);
+  await updateRequestRecord(rootPath, request, {
+    requestState: "applied",
+    processedAt: now,
+    resultMessage: `updated ${request.taskId}`
+  });
+  return {
+    outcome: "applied",
+    requestId: request.requestId,
+    taskId: request.taskId,
+    message: `updated ${request.taskId}`
+  };
+}
+async function acquireWriterLock(rootPath) {
+  const lockPath = path.join(rootPath, ".runtime", "writer.lock.json");
+  await ensureDir(path.dirname(lockPath));
+  const handle = await promises.open(lockPath, "wx");
+  await handle.writeFile(JSON.stringify({
+    acquiredAt: Date.now(),
+    pid: process.pid
+  }, null, 2), "utf8");
+  await handle.close();
+  return async () => {
+    await promises.unlink(lockPath).catch(async () => {
+      await promises.rm(lockPath, { force: true });
+    });
+  };
+}
+async function processSingleRequest(rootPath, request) {
+  if (request.requestState === "applied") {
+    const duplicateTaskId = request.requestType === "create_task" ? request.resultMessage?.match(/T-\d+/)?.[0] ?? null : "taskId" in request ? request.taskId : null;
+    return {
+      outcome: "duplicate",
+      requestId: request.requestId,
+      taskId: duplicateTaskId,
+      message: request.resultMessage
+    };
+  }
+  const release = await acquireWriterLock(rootPath);
+  try {
+    if (request.requestType === "replace_goal") {
+      return await applyReplaceGoalRequest(rootPath, request);
+    }
+    if (request.requestType === "create_task") {
+      return await applyCreateTaskRequest(rootPath, request);
+    }
+    return await applyUpdateTaskRequest(rootPath, request);
+  } finally {
+    await release();
+  }
+}
+async function loadRequest(rootPath, requestId) {
+  const payload = await readJson(buildRequestFilePath(rootPath, requestId));
+  const parsed = RequestSchema.safeParse(payload);
+  return parsed.success ? parsed.data : null;
+}
+async function processHappyOrgRepoRequests(options) {
+  await ensureDir(path.join(options.rootPath, "requests"));
+  const requestIds = options.requestId ? [options.requestId] : (await promises.readdir(path.join(options.rootPath, "requests"), { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.replace(/\.json$/i, ""));
+  const requests = await Promise.all(requestIds.map((requestId) => loadRequest(options.rootPath, requestId)));
+  const orderedRequests = requests.filter((request) => request !== null).sort((left, right) => left.createdAt - right.createdAt || left.requestId.localeCompare(right.requestId));
+  const results = [];
+  for (const request of orderedRequests) {
+    results.push(await processSingleRequest(options.rootPath, request));
+  }
+  return results;
+}
+function nextStatusFromTurnReport(report) {
+  if (report.turnStatus === "task_complete") {
+    return "waiting_close";
+  }
+  if (report.interventionType === "review_needed") {
+    return "waiting_review";
+  }
+  if (report.interventionType === "decision_needed") {
+    return "waiting_decision";
+  }
+  if (report.interventionType === "blocker") {
+    return "blocked";
+  }
+  return "active";
+}
+async function recordHappyOrgTurnReport(options) {
+  const bundle = await loadTaskEnvelope(options.rootPath, options.report.taskId);
+  if (!bundle) {
+    return {
+      outcome: "recovery_required",
+      requestId: `turn-report:${options.report.taskId}`,
+      taskId: options.report.taskId,
+      message: `Task ${options.report.taskId} not found`
+    };
+  }
+  const now = Date.now();
+  const nextStatus = nextStatusFromTurnReport(options.report);
+  const nextTaskValue = {
+    ...bundle.task.value,
+    status: nextStatus,
+    summary: options.report.summary,
+    resultSummary: options.report.turnStatus === "task_complete" ? options.report.summary : bundle.task.value.resultSummary,
+    blocker: nextStatus === "blocked" ? options.report.summary || options.report.blockerCode : null,
+    decisionNeeded: nextStatus === "waiting_decision" ? options.report.decisionNeeded ?? options.report.summary : null,
+    updatedAt: now,
+    lastUpdatedBy: options.report.memberAgentId,
+    activeOwnerAgentId: options.report.memberAgentId,
+    hasActiveOwner: nextStatus === "active",
+    path: options.report.targetArtifact ?? bundle.task.value.path,
+    portablePath: normalizePortablePath(options.report.targetArtifact ?? bundle.task.value.path)
+  };
+  await writeEnvelope(path.join(buildTaskRoot(options.rootPath, options.report.taskId), "TASK.json"), {
+    ...bundle.task,
+    revision: bundle.task.revision + 1,
+    updatedAt: now,
+    updatedBy: options.report.memberAgentId,
+    value: nextTaskValue
+  });
+  await writeEnvelope(path.join(buildTaskRoot(options.rootPath, options.report.taskId), "WORKFLOW.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.workflow?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: options.report.memberAgentId,
+    value: {
+      taskId: options.report.taskId,
+      status: nextStatus,
+      summary: options.report.summary,
+      blocker: nextStatus === "blocked" ? options.report.blockerCode ?? options.report.summary : null,
+      decisionNeeded: nextStatus === "waiting_decision" ? options.report.decisionNeeded ?? options.report.summary : null,
+      adviceRoute: null,
+      adviceSummary: null,
+      lastRequestId: null,
+      updatedAt: now,
+      updatedBy: options.report.memberAgentId
+    }
+  });
+  await writeEnvelope(path.join(buildTaskRoot(options.rootPath, options.report.taskId), "RESULT.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.result?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: options.report.memberAgentId,
+    value: {
+      taskId: options.report.taskId,
+      resultSummary: options.report.turnStatus === "task_complete" ? options.report.summary : bundle.result?.value.resultSummary ?? bundle.task.value.resultSummary,
+      reviewSummary: bundle.result?.value.reviewSummary ?? null,
+      assetCaptureStatus: bundle.result?.value.assetCaptureStatus ?? null,
+      assetCaptureSummary: bundle.result?.value.assetCaptureSummary ?? null,
+      assetReference: options.report.targetArtifact ?? bundle.result?.value.assetReference ?? null,
+      closedAt: nextStatus === "waiting_close" ? now : bundle.result?.value.closedAt ?? null,
+      updatedAt: now,
+      updatedBy: options.report.memberAgentId
+    }
+  });
+  await writeEnvelope(path.join(buildTaskRoot(options.rootPath, options.report.taskId), "LOG.json"), {
+    schemaVersion: HAPPY_ORG_LOCAL_REPO_SCHEMA_VERSION,
+    revision: (bundle.log?.revision ?? 0) + 1,
+    updatedAt: now,
+    updatedBy: options.report.memberAgentId,
+    value: {
+      taskId: options.report.taskId,
+      entries: [
+        ...bundle.log?.value.entries ?? [],
+        buildTaskLogEntry(
+          "turn_report",
+          `Recorded ${options.report.turnStatus} from ${options.report.memberAgentId}`,
+          options.report.summary,
+          options.report.memberAgentId,
+          now
+        )
+      ]
+    }
+  });
+  await rebuildResponsibilities(options.rootPath);
+  return {
+    outcome: "applied",
+    requestId: `turn-report:${options.report.taskId}`,
+    taskId: options.report.taskId,
+    message: `recorded turn report for ${options.report.taskId}`
+  };
+}
+
 function buildSessionRuntimeIndex(metadata) {
   if (!metadata) {
     return null;
@@ -2511,6 +3353,14 @@ function normalizeHappyOrgOptionalText(value) {
   const normalized = value.trim();
   return normalized.length > 0 ? normalized : null;
 }
+async function pathExists(targetPath) {
+  try {
+    await promises.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function deriveHappyOrgTurnReportRepeatFingerprint(report) {
   const repeatFingerprint = normalizeHappyOrgOptionalText(report.repeatFingerprint);
   if (repeatFingerprint) {
@@ -3337,6 +4187,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
   }
   async submitHappyOrgTaskTurnReport(report, submissionKey) {
+    await this.recordHappyOrgTaskTurnReportLocally(report, submissionKey);
     const credentials = await this.ensureHappyOrgControlCredentials();
     if (!credentials) {
       return;
@@ -3386,6 +4237,62 @@ class ApiSessionClient extends node_events.EventEmitter {
       });
     }
   }
+  async recordHappyOrgTaskTurnReportLocally(report, submissionKey) {
+    const rootPath = await this.resolveHappyOrgLocalRepoRoot(report);
+    if (!rootPath) {
+      return;
+    }
+    try {
+      await recordHappyOrgTurnReport({
+        rootPath,
+        report
+      });
+      this.recordedHappyOrgTaskTurnReports.add(submissionKey);
+      logger.debug("[API] Happy Org task turn report recorded into local repo automatically", {
+        taskId: report.taskId,
+        memberAgentId: report.memberAgentId,
+        rootPath,
+        turnStatus: report.turnStatus
+      });
+    } catch (error) {
+      logger.debug("[API] Failed to record Happy Org task turn report into local repo automatically", {
+        taskId: report.taskId,
+        memberAgentId: report.memberAgentId,
+        rootPath,
+        turnStatus: report.turnStatus,
+        error
+      });
+    }
+  }
+  async resolveHappyOrgLocalRepoRoot(report) {
+    const candidatePaths = [
+      normalizeHappyOrgOptionalText(report.specialistHome?.path ?? null),
+      normalizeHappyOrgOptionalText(this.metadata?.path ?? null)
+    ].filter((value) => Boolean(value));
+    const visited = /* @__PURE__ */ new Set();
+    for (const candidatePath of candidatePaths) {
+      let currentPath = candidatePath;
+      while (!visited.has(currentPath)) {
+        visited.add(currentPath);
+        if (await this.isHappyOrgLocalRepoRoot(currentPath, report.taskId)) {
+          return currentPath;
+        }
+        const parentPath = path.dirname(currentPath);
+        if (!parentPath || parentPath === currentPath) {
+          break;
+        }
+        currentPath = parentPath;
+      }
+    }
+    return null;
+  }
+  async isHappyOrgLocalRepoRoot(rootPath, taskId) {
+    const hasTruthMarker = await pathExists(path.join(rootPath, "MIGRATION.json")) || await pathExists(path.join(rootPath, "ORGANIZATION.json"));
+    if (!hasTruthMarker) {
+      return false;
+    }
+    return await pathExists(path.join(rootPath, "tasks", taskId, "TASK.json"));
+  }
   async submitHappyOrgDispatchBusinessAck(candidate) {
     const credentials = await this.ensureHappyOrgControlCredentials();
     if (!credentials) {
@@ -5176,6 +6083,7 @@ exports.HAPPY_CLOUD_DAEMON_PORT = HAPPY_CLOUD_DAEMON_PORT;
 exports.HAPPY_ORG_REPEAT_THRESHOLD = HAPPY_ORG_REPEAT_THRESHOLD;
 exports.HAPPY_ORG_SUMMARY_MAX_LENGTH = HAPPY_ORG_SUMMARY_MAX_LENGTH;
 exports.HAPPY_ORG_TURN_REPORT_TAG = HAPPY_ORG_TURN_REPORT_TAG;
+exports.HappyOrgTurnReportSchema = HappyOrgTurnReportSchema;
 exports.HeadTailPreviewBuffer = HeadTailPreviewBuffer;
 exports.MessageContentSchema = MessageContentSchema;
 exports.acquireDaemonLock = acquireDaemonLock;
@@ -5201,9 +6109,11 @@ exports.logger = logger;
 exports.packageJson = packageJson;
 exports.persistence = persistence;
 exports.preserveSessionRuntimeMetadata = preserveSessionRuntimeMetadata;
+exports.processHappyOrgRepoRequests = processHappyOrgRepoRequests;
 exports.readCredentials = readCredentials;
 exports.readDaemonState = readDaemonState;
 exports.readSettings = readSettings;
+exports.recordHappyOrgTurnReport = recordHappyOrgTurnReport;
 exports.releaseDaemonLock = releaseDaemonLock;
 exports.startOfflineReconnection = startOfflineReconnection;
 exports.updateSettings = updateSettings;