ship: align action audit with main

Author: arul28

apps/ade-cli/src/adeRpcServer.test.ts

@@ -2897,8 +2897,8 @@ describe("adeRpcServer", () => {
   });
 
   it("rejects run_ade_action when the action is not a callable on the domain service", async () => {
-    const { runtime, operationStart, operationFinish } = createRuntime();
-    const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });
+    const fixture = createRuntime();
+    const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
     await initialize(handler, { callerId: "agent-1", role: "agent" });
 
     const response = await callTool(handler, "run_ade_action", {
@@ -2911,11 +2911,6 @@ describe("adeRpcServer", () => {
     expect(JSON.stringify(response.error ?? response.structuredContent ?? {})).toContain(
       "Action 'git.nonexistent_action' is not callable.",
     );
-    expect(operationStart).toHaveBeenCalledTimes(1);
-    expect(operationFinish).toHaveBeenCalledWith(expect.objectContaining({
-      status: "failed",
-      metadataPatch: expect.objectContaining({ resultStatus: "error" }),
-    }));
   });
 
   it("reads ADE action status snapshots across operation/test/chat/pr", async () => {
@@ -3059,45 +3054,6 @@ describe("adeRpcServer", () => {
     expect(operationFinish).not.toHaveBeenCalled();
   });
 
-  it("does not mask successful action responses when audit finish fails", async () => {
-    const { runtime, operationFinish } = createRuntime();
-    operationFinish.mockImplementationOnce(() => {
-      throw new Error("finish failed");
-    });
-    const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });
-
-    await initialize(handler);
-    const response = await callTool(handler, "list_lanes", {});
-
-    expect(response.isError).toBeUndefined();
-    expect(response.structuredContent.lanes).toHaveLength(2);
-    expect(operationFinish).toHaveBeenCalledTimes(1);
-    expect(runtime.logger.warn).toHaveBeenCalledWith(
-      "ade_rpc.action_audit_finish_failed",
-      expect.objectContaining({ actionName: "list_lanes", status: "succeeded" }),
-    );
-  });
-
-  it("records failed audit metadata for returned action failure payloads", async () => {
-    const { runtime, operationFinish } = createRuntime();
-    runtime.gitService.push.mockResolvedValueOnce({ success: false, error: "push failed" });
-    const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });
-
-    await initialize(handler, { callerId: "agent-1", role: "agent" });
-    const response = await callTool(handler, "run_ade_action", {
-      domain: "git",
-      action: "push",
-      args: { laneId: "lane-1" },
-    });
-
-    expect(response.isError).toBeUndefined();
-    expect(response.structuredContent.result.success).toBe(false);
-    expect(operationFinish).toHaveBeenCalledWith(expect.objectContaining({
-      status: "failed",
-      metadataPatch: expect.objectContaining({ resultStatus: "error", error: "push failed" }),
-    }));
-  });
-
   // ---------- Rate limit tests ----------
 
   afterEach(() => {

apps/ade-cli/src/adeRpcServer.ts

@@ -5245,77 +5245,6 @@ export function createAdeRpcRequestHandler(args: {
     throw new JsonRpcError(JsonRpcErrorCode.methodNotFound, `Unsupported ADE action: ${actionName}`);
   };
 
-  const failedActionPayloadMessage = (value: unknown): string | null => {
-    if (!isRecord(value)) return null;
-    const failed = value.ok === false || value.success === false;
-    if (!failed) return null;
-    const error = value.error;
-    if (typeof error === "string" && error.trim()) return error.trim();
-    if (isRecord(error) && typeof error.message === "string" && error.message.trim()) {
-      return error.message.trim();
-    }
-    return "Action returned a failed result.";
-  };
-
-  const actionResultFailureMessage = (value: unknown): string | null => {
-    if (!isRecord(value)) return null;
-    return failedActionPayloadMessage(value) ?? failedActionPayloadMessage(value.result);
-  };
-
-  const finishActionAudit = (
-    actionName: string,
-    operationId: string,
-    status: "succeeded" | "failed",
-    metadataPatch: Record<string, unknown>,
-  ): void => {
-    try {
-      runtime.operationService.finish({ operationId, status, metadataPatch });
-    } catch (error) {
-      runtime.logger.warn("ade_rpc.action_audit_finish_failed", {
-        actionName,
-        operationId,
-        status,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  };
-
-  const callActionWithAudit = async (
-    actionName: string,
-    actionArgs: Record<string, unknown>,
-  ): Promise<unknown> => {
-    const operation = runtime.operationService.start({
-      kind: `ade_action.${actionName}`,
-      metadata: {
-        actionName,
-        callerId: session.identity.callerId,
-        callerRole: session.identity.role,
-        chatSessionId: session.identity.chatSessionId,
-        readOnly: READ_ONLY_TOOLS.has(actionName),
-      },
-    });
-    try {
-      const result = await callAction(actionName, actionArgs);
-      const failureMessage = actionResultFailureMessage(result);
-      if (failureMessage) {
-        finishActionAudit(actionName, operation.operationId, "failed", {
-          resultStatus: "error",
-          error: failureMessage,
-        });
-        return result;
-      }
-      finishActionAudit(actionName, operation.operationId, "succeeded", { resultStatus: "success" });
-      return result;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      finishActionAudit(actionName, operation.operationId, "failed", {
-        resultStatus: "error",
-        error: message,
-      });
-      throw error;
-    }
-  };
-
   const handler = (async (request: JsonRpcRequest): Promise<unknown | null> => {
     const method = typeof request.method === "string" ? request.method : "";
     const params = safeObject(request.params);
@@ -5511,7 +5440,7 @@ export function createAdeRpcRequestHandler(args: {
       const actionName = assertNonEmptyString(params.name, "name");
       const actionArgs = safeObject(params.arguments);
       try {
-        return await callActionWithAudit(actionName, actionArgs);
+        return await callAction(actionName, actionArgs);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {