@thinkingai/ae-cli 6.1.25 → 6.1.27

package/dist/{local-data-upload-client-3P7NIVQ4.js → local-data-upload-client-TWMHFLUA.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   LocalDataUploadError,
   logger
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/local-data-upload-client.ts
 import { createHash } from "crypto";

package/dist/memory-CQKH2JAV.js

@@ -0,0 +1,580 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  buildMemoryCliUrl,
+  getMemoryCli,
+  patchMemoryCli,
+  postMemoryCli
+} from "./chunk-RPBOAQQQ.js";
+import {
+  currentAgentSpaceId
+} from "./chunk-RK6GLDGI.js";
+import "./chunk-CI24BDR2.js";
+import "./chunk-3YVEAZUN.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-GHXZK54S.js";
+import "./chunk-ZL7SGNIA.js";
+import {
+  CliValidationError
+} from "./chunk-WNGFSIOB.js";
+
+// src/commands/memory/shared.ts
+var MEMORY_SERVICE = "memory";
+var MEMORY_STATUSES = ["active", "deleted"];
+var CANDIDATE_VIEWS = ["mine", "pending"];
+var CANDIDATE_STATUSES = ["pending", "approved", "rejected", "withdrawn", "conflicted"];
+function optional(ctx, name) {
+  const value = ctx.str(name).trim();
+  return value || void 0;
+}
+function envOptional(name) {
+  const value = process.env[name]?.trim();
+  return value || void 0;
+}
+function compact(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function query(values) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== void 0 && value !== "") params.set(key, String(value));
+  }
+  const text = params.toString();
+  return text ? `?${text}` : "";
+}
+function assertOneOf(flag, value, allowed) {
+  if (value && !allowed.includes(value)) {
+    throw new Error(`--${flag} must be one of: ${allowed.join(", ")}`);
+  }
+}
+function version(ctx) {
+  const value = ctx.num("version");
+  if (!Number.isInteger(value) || value < 1) throw new Error("--version must be a positive integer");
+  return value;
+}
+function conversationId(ctx) {
+  return optional(ctx, "conversationId") ?? envOptional("TE_AGENT_CONVERSATION_ID");
+}
+function agentId(ctx) {
+  const value = optional(ctx, "agentId") ?? envOptional("TE_AGENT_CURRENT_AGENT_ID");
+  if (!value) throw new Error("--agent-id is required outside an Agent conversation");
+  return value;
+}
+function targetQuery(ctx) {
+  const workspaceId = optional(ctx, "workspaceId") ?? currentAgentSpaceId();
+  const currentConversationId = conversationId(ctx);
+  if (!workspaceId && !currentConversationId) {
+    throw new Error(
+      "Memory target is required. Provide --workspace-id or --conversation-id, or run inside an AgentSpace conversation."
+    );
+  }
+  return query({ agentSpaceId: workspaceId, conversationId: currentConversationId });
+}
+function targetPath(ctx) {
+  return `target${targetQuery(ctx)}`;
+}
+async function resolveMemoryTarget(ctx) {
+  return getMemoryCli(ctx, targetPath(ctx));
+}
+function resourcePath(agentSpaceId, suffix) {
+  return `agent-spaces/${encodeURIComponent(agentSpaceId)}/${suffix.replace(/^\/+/, "")}`;
+}
+function previewResourcePath(ctx, suffix) {
+  const id = optional(ctx, "workspaceId") ?? currentAgentSpaceId() ?? ":resolved-workspace-id";
+  return resourcePath(id, suffix);
+}
+function targetDryRun(ctx, method, suffix, body2) {
+  return {
+    method,
+    url: buildMemoryCliUrl(ctx, previewResourcePath(ctx, suffix)),
+    params: { target_url: buildMemoryCliUrl(ctx, targetPath(ctx)) },
+    ...body2 === void 0 ? {} : { body: body2 }
+  };
+}
+async function targetGet(ctx, suffix) {
+  const target = await resolveMemoryTarget(ctx);
+  return getMemoryCli(ctx, resourcePath(target.agentSpaceId, suffix));
+}
+async function targetPost(ctx, suffix, body2) {
+  const target = await resolveMemoryTarget(ctx);
+  return postMemoryCli(ctx, resourcePath(target.agentSpaceId, suffix), body2);
+}
+async function targetPatch(ctx, suffix, body2) {
+  const target = await resolveMemoryTarget(ctx);
+  return patchMemoryCli(ctx, resourcePath(target.agentSpaceId, suffix), body2);
+}
+var targetFlags = [
+  { name: "workspace-id", type: "string", required: false, desc: "AgentSpace ID; defaults to the current AgentSpace or resolves from the current conversation" },
+  { name: "conversation-id", type: "string", required: false, desc: "Conversation ID used to verify or resolve the AgentSpace target" }
+];
+function memoryBody(ctx) {
+  return compact({ title: optional(ctx, "title"), content: ctx.str("content"), scopeType: "space", agentId: null, conversationId: conversationId(ctx) });
+}
+function memoryMutationBody(ctx) {
+  return compact({ title: optional(ctx, "title"), content: ctx.str("content"), scopeType: "space", agentId: null, version: version(ctx), conversationId: conversationId(ctx) });
+}
+function memoryStateCommand(action) {
+  return {
+    service: MEMORY_SERVICE,
+    command: `+${action}`,
+    description: `${action[0].toUpperCase()}${action.slice(1)} an AgentSpace memory`,
+    flags: [...targetFlags, { name: "id", type: "string", required: true, desc: "Memory ID" }, { name: "version", type: "number", required: true, desc: "Current memory version" }],
+    risk: action === "delete" ? "high-risk-write" : "write",
+    preflight: action === "delete" ? version : void 0,
+    validate: version,
+    dryRun: (ctx) => targetDryRun(ctx, "POST", `memories/${encodeURIComponent(ctx.str("id"))}/${action}`, compact({ version: version(ctx), conversationId: conversationId(ctx) })),
+    execute: (ctx) => targetPost(ctx, `memories/${encodeURIComponent(ctx.str("id"))}/${action}`, compact({ version: version(ctx), conversationId: conversationId(ctx) }))
+  };
+}
+function draftContentBody(ctx) {
+  return compact({ version: version(ctx), title: optional(ctx, "title"), content: ctx.str("content"), scopeType: "space", agentId: null });
+}
+function draftActionCommand(action) {
+  const contentFlags = action === "submit" ? [{ name: "title", type: "string", required: false, desc: "Final title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Final content" }] : [];
+  return {
+    service: MEMORY_SERVICE,
+    command: `+draft-${action}`,
+    description: `${action === "delete" ? "Delete" : "Submit"} a private memory draft`,
+    flags: [...targetFlags, { name: "draft-id", type: "string", required: true, desc: "Draft ID" }, { name: "version", type: "number", required: true, desc: "Current draft version" }, ...contentFlags],
+    risk: action === "delete" ? "high-risk-write" : "write",
+    preflight: action === "delete" ? version : void 0,
+    validate: version,
+    dryRun: (ctx) => targetDryRun(ctx, "POST", `drafts/${encodeURIComponent(ctx.str("draftId"))}/${action}`, action === "delete" ? { version: version(ctx) } : draftContentBody(ctx)),
+    execute: (ctx) => targetPost(ctx, `drafts/${encodeURIComponent(ctx.str("draftId"))}/${action}`, action === "delete" ? { version: version(ctx) } : draftContentBody(ctx))
+  };
+}
+function candidateBody(ctx) {
+  const targetMemoryId = optional(ctx, "targetMemoryId");
+  const targetMemoryVersion = ctx.optionalNum("targetMemoryVersion");
+  if (targetMemoryId === void 0 !== (targetMemoryVersion === void 0)) {
+    throw new Error("--target-memory-id and --target-memory-version must be provided together");
+  }
+  return compact({ title: optional(ctx, "title"), content: ctx.str("content"), scopeType: "space", agentId: null, targetMemoryId, targetMemoryVersion });
+}
+function candidateActionCommand(action) {
+  const reasonFlag = action === "reject" ? [{ name: "reason", type: "string", required: false, maxLength: 1e3, desc: "Optional rejection reason" }] : [];
+  return {
+    service: MEMORY_SERVICE,
+    command: `+candidate-${action}`,
+    description: `${action[0].toUpperCase()}${action.slice(1)} a shared AgentSpace memory candidate`,
+    flags: [...targetFlags, { name: "candidate-id", type: "string", required: true, desc: "Candidate ID" }, { name: "version", type: "number", required: true, desc: "Current candidate version" }, ...reasonFlag],
+    risk: "write",
+    validate: version,
+    dryRun: (ctx) => targetDryRun(ctx, "POST", `candidates/${encodeURIComponent(ctx.str("candidateId"))}/${action}`, compact({ version: version(ctx), reason: action === "reject" ? optional(ctx, "reason") : void 0 })),
+    execute: (ctx) => targetPost(ctx, `candidates/${encodeURIComponent(ctx.str("candidateId"))}/${action}`, compact({ version: version(ctx), reason: action === "reject" ? optional(ctx, "reason") : void 0 }))
+  };
+}
+function settingsBody(ctx) {
+  const autoExtractionEnabled = ctx.json("autoExtractionEnabled");
+  const excluded = ctx.json("excluded");
+  const currentConversationId = conversationId(ctx);
+  if (autoExtractionEnabled === void 0 && excluded === void 0) throw new Error("Provide --auto-extraction-enabled or --excluded");
+  if (excluded !== void 0 && !currentConversationId) throw new Error("--excluded requires --conversation-id outside an Agent conversation");
+  return compact({ autoExtractionEnabled, conversationId: excluded === void 0 ? void 0 : currentConversationId, excluded });
+}
+function retiredCommand(name, replacement, flags = []) {
+  return {
+    service: MEMORY_SERVICE,
+    command: name,
+    hidden: true,
+    description: "Retired legacy user-memory command",
+    flags,
+    risk: "read",
+    execute: async () => {
+      throw new CliValidationError(`${name} was retired with AgentSpace memory v2.`, {
+        code: "MEMORY_COMMAND_RETIRED",
+        hint: replacement
+      });
+    }
+  };
+}
+var retiredIdFlag = { name: "id", type: "string", required: false, desc: "Retired resource ID" };
+var retiredAgentFlag = { name: "agent-id", type: "string", required: false, desc: "Retired Agent target" };
+var retiredScopeFlag = { name: "scope", type: "string", required: false, desc: "Retired memory scope" };
+
+// src/commands/memory/list.ts
+var listMemories = {
+  service: MEMORY_SERVICE,
+  command: "+list",
+  description: "List memories in the resolved AgentSpace",
+  flags: [...targetFlags, { name: "status", type: "string", required: false, default: "active", desc: "active | deleted" }, { name: "query", type: "string", required: false, desc: "Search text in memory title or content" }, { name: "cursor", type: "string", required: false, desc: "Pagination cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  validate: (ctx) => assertOneOf("status", ctx.str("status"), MEMORY_STATUSES),
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `memories${query({ status: ctx.str("status") || "active", query: optional(ctx, "query"), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `memories${query({ status: ctx.str("status") || "active", query: optional(ctx, "query"), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/get.ts
+var getMemory = {
+  service: MEMORY_SERVICE,
+  command: "+get",
+  description: "Get one AgentSpace memory and recent revisions",
+  flags: [...targetFlags, { name: "id", type: "string", required: true, desc: "Memory ID" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `memories/${encodeURIComponent(ctx.str("id"))}`),
+  execute: (ctx) => targetGet(ctx, `memories/${encodeURIComponent(ctx.str("id"))}`)
+};
+
+// src/commands/memory/create.ts
+var createMemory = {
+  service: MEMORY_SERVICE,
+  command: "+create",
+  description: "Create an AgentSpace memory or submit it for shared-space review",
+  flags: [...targetFlags, { name: "title", type: "string", required: false, desc: "Optional memory title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Memory content, up to 4000 characters" }],
+  risk: "write",
+  dryRun: (ctx) => targetDryRun(ctx, "POST", "memories", memoryBody(ctx)),
+  execute: (ctx) => targetPost(ctx, "memories", memoryBody(ctx))
+};
+
+// src/commands/memory/update.ts
+var updateMemory = {
+  service: MEMORY_SERVICE,
+  command: "+update",
+  description: "Update an AgentSpace memory using optimistic concurrency",
+  flags: [...targetFlags, { name: "id", type: "string", required: true, desc: "Memory ID" }, { name: "version", type: "number", required: true, desc: "Current memory version" }, { name: "title", type: "string", required: false, desc: "Replacement title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Replacement content" }],
+  risk: "write",
+  validate: version,
+  dryRun: (ctx) => targetDryRun(ctx, "PATCH", `memories/${encodeURIComponent(ctx.str("id"))}`, memoryMutationBody(ctx)),
+  execute: (ctx) => targetPatch(ctx, `memories/${encodeURIComponent(ctx.str("id"))}`, memoryMutationBody(ctx))
+};
+
+// src/commands/memory/delete.ts
+var deleteMemory = memoryStateCommand("delete");
+
+// src/commands/memory/history.ts
+var historyMemory = {
+  service: MEMORY_SERVICE,
+  command: "+history",
+  description: "List revision history for one AgentSpace memory",
+  flags: [...targetFlags, { name: "id", type: "string", required: true, desc: "Memory ID" }, { name: "cursor", type: "number", required: false, min: 1, desc: "Revision cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `memories/${encodeURIComponent(ctx.str("id"))}/history${query({ cursor: ctx.optionalNum("cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `memories/${encodeURIComponent(ctx.str("id"))}/history${query({ cursor: ctx.optionalNum("cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/pin.ts
+var pinMemory = memoryStateCommand("pin");
+
+// src/commands/memory/unpin.ts
+var unpinMemory = memoryStateCommand("unpin");
+
+// src/commands/memory/restore.ts
+var restoreMemory = memoryStateCommand("restore");
+
+// src/commands/memory/context.ts
+var contextMemory = {
+  service: MEMORY_SERVICE,
+  command: "+context",
+  description: "Preview the memory context that one Agent would receive",
+  flags: [...targetFlags, { name: "agent-id", type: "string", required: false, desc: "Agent ID; defaults to TE_AGENT_CURRENT_AGENT_ID" }, { name: "limit", type: "number", required: false, min: 1, max: 50, desc: "Maximum memories, 1-50" }],
+  risk: "read",
+  validate: agentId,
+  dryRun: (ctx) => targetDryRun(ctx, "POST", "context", compact({ agentId: agentId(ctx), conversationId: conversationId(ctx), limit: ctx.optionalNum("limit") })),
+  execute: (ctx) => targetPost(ctx, "context", compact({ agentId: agentId(ctx), conversationId: conversationId(ctx), limit: ctx.optionalNum("limit") }))
+};
+
+// src/commands/memory/extract.ts
+var extractMemory = {
+  service: MEMORY_SERVICE,
+  command: "+extract",
+  description: "Start asynchronous memory extraction from an AgentSpace conversation",
+  flags: targetFlags,
+  risk: "write",
+  validate: (ctx) => {
+    if (!conversationId(ctx)) throw new Error("--conversation-id is required outside an Agent conversation");
+  },
+  dryRun: (ctx) => targetDryRun(ctx, "POST", "extract", { conversationId: conversationId(ctx) }),
+  execute: (ctx) => targetPost(ctx, "extract", { conversationId: conversationId(ctx) })
+};
+
+// src/commands/memory/source-list.ts
+var listMemorySources = {
+  service: MEMORY_SERVICE,
+  command: "+source-list",
+  description: "List conversations eligible as AgentSpace memory extraction sources",
+  flags: [...targetFlags, { name: "cursor", type: "string", required: false, desc: "Pagination cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `sources${query({ cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `sources${query({ cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/job-list.ts
+var listMemoryJobs = {
+  service: MEMORY_SERVICE,
+  command: "+job-list",
+  description: "List AgentSpace memory extraction jobs",
+  flags: [...targetFlags, { name: "cursor", type: "string", required: false, desc: "Pagination cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `jobs${query({ conversationId: conversationId(ctx), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `jobs${query({ conversationId: conversationId(ctx), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/job-get.ts
+var getMemoryJob = {
+  service: MEMORY_SERVICE,
+  command: "+job-get",
+  description: "Get one AgentSpace memory extraction job",
+  flags: [...targetFlags, { name: "job-id", type: "string", required: true, desc: "Extraction job ID returned by +extract or +job-list" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `jobs/${encodeURIComponent(ctx.str("jobId"))}`),
+  execute: (ctx) => targetGet(ctx, `jobs/${encodeURIComponent(ctx.str("jobId"))}`)
+};
+
+// src/commands/memory/draft-list.ts
+var listMemoryDrafts = {
+  service: MEMORY_SERVICE,
+  command: "+draft-list",
+  description: "List private memory drafts created by the current user",
+  flags: [...targetFlags, { name: "cursor", type: "string", required: false, desc: "Pagination cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `drafts${query({ cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `drafts${query({ cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/draft-get.ts
+var getMemoryDraft = {
+  service: MEMORY_SERVICE,
+  command: "+draft-get",
+  description: "Get one private memory draft",
+  flags: [...targetFlags, { name: "draft-id", type: "string", required: true, desc: "Draft ID" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `drafts/${encodeURIComponent(ctx.str("draftId"))}`),
+  execute: (ctx) => targetGet(ctx, `drafts/${encodeURIComponent(ctx.str("draftId"))}`)
+};
+
+// src/commands/memory/draft-update.ts
+var updateMemoryDraft = {
+  service: MEMORY_SERVICE,
+  command: "+draft-update",
+  description: "Update a private memory draft",
+  flags: [...targetFlags, { name: "draft-id", type: "string", required: true, desc: "Draft ID" }, { name: "version", type: "number", required: true, desc: "Current draft version" }, { name: "title", type: "string", required: false, desc: "Replacement title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Replacement content" }],
+  risk: "write",
+  validate: version,
+  dryRun: (ctx) => targetDryRun(ctx, "PATCH", `drafts/${encodeURIComponent(ctx.str("draftId"))}`, draftContentBody(ctx)),
+  execute: (ctx) => targetPatch(ctx, `drafts/${encodeURIComponent(ctx.str("draftId"))}`, draftContentBody(ctx))
+};
+
+// src/commands/memory/draft-delete.ts
+var deleteMemoryDraft = draftActionCommand("delete");
+
+// src/commands/memory/draft-submit.ts
+var submitMemoryDraft = draftActionCommand("submit");
+
+// src/commands/memory/candidate-list.ts
+var listMemoryCandidates = {
+  service: MEMORY_SERVICE,
+  command: "+candidate-list",
+  description: "List shared AgentSpace memory candidates",
+  flags: [...targetFlags, { name: "view", type: "string", required: false, default: "mine", desc: "mine | pending" }, { name: "status", type: "string", required: false, desc: "Filter the mine view by candidate status" }, { name: "cursor", type: "string", required: false, desc: "Pagination cursor" }, { name: "limit", type: "number", required: false, default: 20, min: 1, max: 50, desc: "Page size, 1-50; default 20" }],
+  risk: "read",
+  validate: (ctx) => {
+    assertOneOf("view", ctx.str("view"), CANDIDATE_VIEWS);
+    assertOneOf("status", optional(ctx, "status"), CANDIDATE_STATUSES);
+    if (ctx.str("view") === "pending" && optional(ctx, "status")) throw new Error("--status is only valid with --view mine");
+  },
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `candidates${query({ view: ctx.str("view") || "mine", status: optional(ctx, "status"), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`),
+  execute: (ctx) => targetGet(ctx, `candidates${query({ view: ctx.str("view") || "mine", status: optional(ctx, "status"), cursor: optional(ctx, "cursor"), limit: ctx.num("limit") || 20 })}`)
+};
+
+// src/commands/memory/candidate-get.ts
+var getMemoryCandidate = {
+  service: MEMORY_SERVICE,
+  command: "+candidate-get",
+  description: "Get one shared AgentSpace memory candidate",
+  flags: [...targetFlags, { name: "candidate-id", type: "string", required: true, desc: "Candidate ID" }],
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `candidates/${encodeURIComponent(ctx.str("candidateId"))}`),
+  execute: (ctx) => targetGet(ctx, `candidates/${encodeURIComponent(ctx.str("candidateId"))}`)
+};
+
+// src/commands/memory/candidate-submit.ts
+var submitMemoryCandidate = {
+  service: MEMORY_SERVICE,
+  command: "+candidate-submit",
+  description: "Submit a new or replacement memory candidate to a shared AgentSpace",
+  flags: [...targetFlags, { name: "title", type: "string", required: false, desc: "Optional candidate title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Candidate content" }, { name: "target-memory-id", type: "string", required: false, desc: "Existing memory ID for a replacement proposal" }, { name: "target-memory-version", type: "number", required: false, min: 1, desc: "Current version of the replacement target" }],
+  risk: "write",
+  validate: candidateBody,
+  dryRun: (ctx) => targetDryRun(ctx, "POST", "candidates", candidateBody(ctx)),
+  execute: (ctx) => targetPost(ctx, "candidates", candidateBody(ctx))
+};
+
+// src/commands/memory/candidate-approve.ts
+var approveMemoryCandidate = candidateActionCommand("approve");
+
+// src/commands/memory/candidate-reject.ts
+var rejectMemoryCandidate = candidateActionCommand("reject");
+
+// src/commands/memory/candidate-withdraw.ts
+var withdrawMemoryCandidate = candidateActionCommand("withdraw");
+
+// src/commands/memory/candidate-resubmit.ts
+function body(ctx) {
+  return compact({ version: version(ctx), title: optional(ctx, "title"), content: ctx.str("content"), scopeType: "space", agentId: null });
+}
+var resubmitMemoryCandidate = {
+  service: MEMORY_SERVICE,
+  command: "+candidate-resubmit",
+  description: "Resubmit a rejected, withdrawn, or conflicted memory candidate",
+  flags: [...targetFlags, { name: "candidate-id", type: "string", required: true, desc: "Previous candidate ID" }, { name: "version", type: "number", required: true, desc: "Current candidate version" }, { name: "title", type: "string", required: false, desc: "Replacement title" }, { name: "content", type: "string", required: true, maxLength: 4e3, desc: "Replacement content" }],
+  risk: "write",
+  validate: version,
+  dryRun: (ctx) => targetDryRun(ctx, "POST", `candidates/${encodeURIComponent(ctx.str("candidateId"))}/resubmit`, body(ctx)),
+  execute: (ctx) => targetPost(ctx, `candidates/${encodeURIComponent(ctx.str("candidateId"))}/resubmit`, body(ctx))
+};
+
+// src/commands/memory/settings-get.ts
+var getMemorySettings = {
+  service: MEMORY_SERVICE,
+  command: "+settings-get",
+  description: "Get AgentSpace memory extraction settings",
+  flags: targetFlags,
+  risk: "read",
+  dryRun: (ctx) => targetDryRun(ctx, "GET", `settings${query({ conversationId: conversationId(ctx) })}`),
+  execute: (ctx) => targetGet(ctx, `settings${query({ conversationId: conversationId(ctx) })}`)
+};
+
+// src/commands/memory/settings-update.ts
+var updateMemorySettings = {
+  service: MEMORY_SERVICE,
+  command: "+settings-update",
+  description: "Update AgentSpace automatic memory extraction settings",
+  flags: [...targetFlags, { name: "auto-extraction-enabled", type: "boolean", required: false, desc: "Enable or disable automatic extraction for the AgentSpace" }, { name: "excluded", type: "boolean", required: false, desc: "Exclude or include the target conversation" }],
+  risk: "write",
+  validate: settingsBody,
+  dryRun: (ctx) => targetDryRun(ctx, "PATCH", "settings", settingsBody(ctx)),
+  execute: (ctx) => targetPatch(ctx, "settings", settingsBody(ctx))
+};
+
+// src/commands/memory/retired-submit-candidates.ts
+var retiredSubmitCandidates = retiredCommand("+submit-candidates", "Use ae-cli memory +candidate-submit.", [
+  { name: "candidates-json", type: "string", required: false, desc: "Retired candidate JSON input" },
+  { name: "stdin", type: "boolean", required: false, desc: "Retired stdin input switch" },
+  { name: "source-type", type: "string", required: false, desc: "Retired source type" },
+  { name: "source-name", type: "string", required: false, desc: "Retired source name" },
+  { name: "source-agent", type: "string", required: false, desc: "Retired source Agent name" },
+  { name: "source-session-id", type: "string", required: false, desc: "Retired source session ID" },
+  retiredScopeFlag,
+  retiredAgentFlag,
+  { name: "auto-approve", type: "boolean", required: false, desc: "Retired automatic approval switch" }
+]);
+
+// src/commands/memory/retired-pending-list.ts
+var retiredPendingList = retiredCommand("+pending-list", "Use ae-cli memory +candidate-list --view pending.");
+
+// src/commands/memory/retired-pending-approve.ts
+var retiredPendingApprove = retiredCommand("+pending-approve", "Use ae-cli memory +candidate-approve.", [retiredIdFlag]);
+
+// src/commands/memory/retired-pending-reject.ts
+var retiredPendingReject = retiredCommand("+pending-reject", "Use ae-cli memory +candidate-reject.", [retiredIdFlag]);
+
+// src/commands/memory/retired-organize.ts
+var retiredOrganize = retiredCommand("+organize", "Use ae-cli memory +extract.", [retiredAgentFlag, retiredScopeFlag]);
+
+// src/commands/memory/retired-default-get.ts
+var retiredDefaultGet = retiredCommand("+default-get", "Use ae-cli workspace capability list.", [retiredAgentFlag]);
+
+// src/commands/memory/retired-default-save.ts
+var retiredDefaultSave = retiredCommand("+default-save", "Use ae-cli workspace capability set.", [
+  retiredAgentFlag,
+  { name: "selection-json", type: "string", required: false, desc: "Retired session selection JSON" }
+]);
+
+// src/commands/memory/retired-default-clear.ts
+var retiredDefaultClear = retiredCommand("+default-clear", "Use ae-cli workspace capability set.", [retiredAgentFlag]);
+
+// src/commands/memory/retired-mark-used.ts
+var retiredMarkUsed = retiredCommand("+mark-used", "Memory usage accounting is handled automatically by the AgentSpace runtime.", [
+  { name: "ids", type: "json", required: false, desc: "Retired memory ID list" },
+  retiredAgentFlag
+]);
+
+// src/commands/memory/retired-write-context.ts
+var retiredWriteContext = retiredCommand("+write-context", "Use ae-cli memory +context; AgentSpace runtime injection is automatic.", [
+  { name: "file", type: "string", required: false, desc: "Retired local output file" },
+  retiredAgentFlag,
+  { name: "limit", type: "number", required: false, desc: "Retired context limit" }
+]);
+
+// src/commands/memory/index.ts
+var commands = [
+  listMemories,
+  getMemory,
+  createMemory,
+  updateMemory,
+  deleteMemory,
+  historyMemory,
+  pinMemory,
+  unpinMemory,
+  restoreMemory,
+  contextMemory,
+  extractMemory,
+  listMemorySources,
+  listMemoryJobs,
+  getMemoryJob,
+  listMemoryDrafts,
+  getMemoryDraft,
+  updateMemoryDraft,
+  deleteMemoryDraft,
+  submitMemoryDraft,
+  listMemoryCandidates,
+  getMemoryCandidate,
+  submitMemoryCandidate,
+  approveMemoryCandidate,
+  rejectMemoryCandidate,
+  withdrawMemoryCandidate,
+  resubmitMemoryCandidate,
+  getMemorySettings,
+  updateMemorySettings,
+  retiredSubmitCandidates,
+  retiredPendingList,
+  retiredPendingApprove,
+  retiredPendingReject,
+  retiredOrganize,
+  retiredDefaultGet,
+  retiredDefaultSave,
+  retiredDefaultClear,
+  retiredMarkUsed,
+  retiredWriteContext
+];
+var memory_default = commands;
+export {
+  approveMemoryCandidate,
+  contextMemory,
+  createMemory,
+  memory_default as default,
+  deleteMemory,
+  deleteMemoryDraft,
+  extractMemory,
+  getMemory,
+  getMemoryCandidate,
+  getMemoryDraft,
+  getMemoryJob,
+  getMemorySettings,
+  historyMemory,
+  listMemories,
+  listMemoryCandidates,
+  listMemoryDrafts,
+  listMemoryJobs,
+  listMemorySources,
+  pinMemory,
+  rejectMemoryCandidate,
+  restoreMemory,
+  resubmitMemoryCandidate,
+  retiredDefaultClear,
+  retiredDefaultGet,
+  retiredDefaultSave,
+  retiredMarkUsed,
+  retiredOrganize,
+  retiredPendingApprove,
+  retiredPendingList,
+  retiredPendingReject,
+  retiredSubmitCandidates,
+  retiredWriteContext,
+  submitMemoryCandidate,
+  submitMemoryDraft,
+  unpinMemory,
+  updateMemory,
+  updateMemoryDraft,
+  updateMemorySettings,
+  withdrawMemoryCandidate
+};

package/dist/{metadata-JRYKNUS5.js → metadata-NR3PHR23.js}

@@ -1,19 +1,19 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   withAsyncArtifactLifecycle
-} from "./chunk-XKIW3QMF.js";
+} from "./chunk-AQJPNWZF.js";
 import {
   createCapabilityCommand
-} from "./chunk-2FJM4HRV.js";
-import "./chunk-QYXDJOLA.js";
+} from "./chunk-MWIA43UJ.js";
+import "./chunk-VZZNLV3I.js";
 import {
   registerCapabilityGatewayRoute
 } from "./chunk-KPQY44JQ.js";
-import "./chunk-BW7JUDEI.js";
+import "./chunk-6VNIR4AP.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-DU72X2IO.js";
-import "./chunk-IG3DYEIR.js";
-import "./chunk-YVGXGTD6.js";
+import "./chunk-GHXZK54S.js";
+import "./chunk-ZL7SGNIA.js";
+import "./chunk-WNGFSIOB.js";
 
 // src/commands/metadata/shared.ts
 function createCapabilityCommand2(config) {

package/dist/{model-ZS7HVGKN.js → model-VX5M2CJ6.js}

@@ -6,17 +6,20 @@ import {
   MultiselectCancelled,
   promptSingleCheckboxSelect
 } from "./chunk-7K24F7T2.js";
+import {
+  assertLegacyWorkspaceCommand
+} from "./chunk-RK6GLDGI.js";
 import {
   TeAgentApiError,
   TeAgentCredentialsError,
   getClaudeConfigDir,
   getSandboxModels,
   postSandboxModelSelection
-} from "./chunk-KJDOTPYU.js";
+} from "./chunk-3YVEAZUN.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-DU72X2IO.js";
-import "./chunk-IG3DYEIR.js";
-import "./chunk-YVGXGTD6.js";
+import "./chunk-GHXZK54S.js";
+import "./chunk-ZL7SGNIA.js";
+import "./chunk-WNGFSIOB.js";
 
 // src/commands/model/index.ts
 import { existsSync, readFileSync } from "fs";
@@ -54,6 +57,7 @@ function isCurrentModel(model, current) {
   return model.scope === "system" && Boolean(current.providerModelId) && model.modelId === current.providerModelId;
 }
 async function runModelPicker() {
+  assertLegacyWorkspaceCommand("model");
   const current = readCurrentModelSelection();
   const models = await getSandboxModels();
   if (models.length === 0) {
@@ -99,7 +103,7 @@ async function runModelPicker() {
 `);
 }
 function registerModel(program) {
-  program.command("model").description("Choose and switch the current workspace model (te-agent sandbox only)").action(async () => {
+  program.command("model").description("Choose and switch the legacy sandbox workspace model (not AgentSpace)").action(async () => {
     try {
       await runModelPicker();
     } catch (err) {