@agenr/openclaw-plugin 3.3.0 → 2026.6.2

package/dist/service-RHNB5AEQ.js

@@ -0,0 +1,861 @@
+import {
+  INITIAL_GOAL_GENERATION,
+  createToolSuccessProjection,
+  nextGoalGenerationAfterObjectiveChange
+} from "./chunk-OWGQWQUP.js";
+import {
+  CLOSE_EVENT_HISTORY_LIMIT,
+  WORKING_MEMORY_MISCONFIGURED_MESSAGE,
+  createFailure,
+  createWorkingContextFullProjection,
+  createWorkingContextStubProjection,
+  isCloseManagedStatus,
+  isMutableWorkingSetStatus,
+  isTrustedHostMutationSource,
+  isTrustedHostOnlyWorkingOperation,
+  normalizeEventLimit,
+  normalizeListLimit,
+  workingMemoryNotReadyFailure,
+  writeFailureToResult
+} from "./chunk-NSLTJBUC.js";
+
+// src/app/working-memory/close-service.ts
+function resolveCloseTerminalStatus(closeMode) {
+  return closeMode === "abandon" ? "abandoned" : "closed";
+}
+function buildWorkingCloseSnapshot(input) {
+  const finalCheckpoint = buildFinalCheckpoint(input);
+  const candidates = [...input.snapshot.candidates ?? []];
+  if (input.createEpisode && !candidates.some((candidate) => candidate.kind === "episodic")) {
+    candidates.push({
+      kind: "episodic",
+      summary: finalCheckpoint.summary,
+      provenance: {
+        evidenceEventSequences: input.eventSequences,
+        sourceRef: `working_set:${input.workingSetId}#rev:${input.currentRevision}`,
+        note: input.closeReason
+      },
+      promotionStatus: "pending"
+    });
+  }
+  return {
+    snapshot: {
+      ...input.snapshot,
+      checkpoint: finalCheckpoint,
+      candidates: candidates.length > 0 ? candidates : void 0,
+      lastMaterialChange: input.closeReason
+    },
+    candidates
+  };
+}
+function buildFinalCheckpoint(input) {
+  const summary = normalizeSummary(input.closeReason) ?? input.snapshot.summary ?? input.snapshot.objective ?? "Working set closed.";
+  return {
+    summary,
+    recordedAt: input.now,
+    ...input.snapshot.nextActions && input.snapshot.nextActions.length > 0 ? { nextActions: input.snapshot.nextActions.map((action) => action.text).filter((text) => text.trim().length > 0) } : {},
+    ...input.snapshot.blockers && input.snapshot.blockers.length > 0 ? { blockers: input.snapshot.blockers } : {}
+  };
+}
+function normalizeSummary(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+
+// src/app/working-memory/repository.ts
+function isWorkingSetCreateFailure(result) {
+  return "kind" in result;
+}
+function isWorkingSetWriteFailure(result) {
+  return "kind" in result;
+}
+
+// src/app/working-memory/scope-resolver.ts
+function resolveWorkingScope(input) {
+  const scope = normalizeWorkingScope(input);
+  if (scope.taskId) {
+    return {
+      ok: true,
+      scope: {
+        ...scope,
+        scopeKind: "task",
+        scopeKey: `task:${scope.taskId}`
+      }
+    };
+  }
+  if (scope.conversationKey) {
+    return {
+      ok: true,
+      scope: {
+        ...scope,
+        scopeKind: "conversation",
+        scopeKey: `conversation:${scope.conversationKey}`
+      }
+    };
+  }
+  if (scope.gitRoot && scope.gitBranch) {
+    return {
+      ok: true,
+      scope: {
+        ...scope,
+        scopeKind: "git_branch",
+        scopeKey: buildScopeKey("git_branch", [scope.project, scope.gitRoot, scope.gitBranch])
+      }
+    };
+  }
+  if (scope.gitRoot && scope.cwd) {
+    return {
+      ok: true,
+      scope: {
+        ...scope,
+        scopeKind: "git_cwd",
+        scopeKey: buildScopeKey("git_cwd", [scope.project, scope.gitRoot, scope.cwd])
+      }
+    };
+  }
+  return {
+    ok: false,
+    code: "missing_scope",
+    message: "Working memory needs a task, conversation, or git scope."
+  };
+}
+function normalizeWorkingScope(input) {
+  const scope = input ?? {};
+  return {
+    ...normalizeField("sessionId", scope.sessionId),
+    ...normalizeField("gitRoot", scope.gitRoot),
+    ...normalizeField("gitBranch", scope.gitBranch),
+    ...normalizeField("cwd", scope.cwd),
+    ...normalizeField("project", scope.project),
+    ...normalizeField("taskId", scope.taskId),
+    ...normalizeField("conversationKey", scope.conversationKey)
+  };
+}
+function buildScopeKey(prefix, parts) {
+  return [prefix, ...parts.filter((part) => part !== void 0)].join(":");
+}
+function normalizeField(key, value) {
+  if (typeof value !== "string") {
+    return {};
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? { [key]: trimmed } : {};
+}
+
+// src/app/working-memory/find-current-set.ts
+async function lookupCurrentWorkingSets(scope, repository) {
+  const scopeResolution = resolveWorkingScope(scope);
+  if (!scopeResolution.ok) {
+    return createFailure("missing_scope", scopeResolution.message);
+  }
+  const matches = await repository.findCurrentWorkingSets(scopeResolution.scope);
+  if (matches.length > 1) {
+    return createFailure("ambiguous_scope", "Multiple current working sets matched the resolved scope.", {
+      scopeKey: scopeResolution.scope.scopeKey,
+      workingSetIds: matches.map((match) => match.id)
+    });
+  }
+  return {
+    ok: true,
+    scope: scopeResolution.scope,
+    matches
+  };
+}
+async function findUniqueCurrentWorkingSet(scope, repository) {
+  const lookup = await lookupCurrentWorkingSets(scope, repository);
+  if (!lookup.ok) {
+    return lookup;
+  }
+  if (lookup.matches.length === 0) {
+    return createFailure("missing_active_set", "No current working set matched the resolved scope.", {
+      scopeKey: lookup.scope.scopeKey
+    });
+  }
+  return {
+    ok: true,
+    workingSet: lookup.matches[0],
+    scope: lookup.scope
+  };
+}
+
+// src/app/working-memory/select-working-set.ts
+async function selectWorkingSet(params, repository) {
+  const workingSetId = params.workingSetId?.trim();
+  if (workingSetId) {
+    const workingSet = await repository.getWorkingSet(workingSetId);
+    if (!workingSet) {
+      return createFailure("not_found", `Working set ${workingSetId} was not found.`, { workingSetId });
+    }
+    return { ok: true, workingSet };
+  }
+  const current = await findUniqueCurrentWorkingSet(params.scope, repository);
+  if (!current.ok) {
+    return current;
+  }
+  return {
+    ok: true,
+    workingSet: current.workingSet,
+    scope: current.scope
+  };
+}
+
+// src/app/working-memory/validation.ts
+function normalizeRequiredString(value, message) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return createFailure("invalid_request", message);
+  }
+  return { ok: true, value: trimmed };
+}
+function normalizeExpectedRevision(value) {
+  if (value === void 0 || !Number.isInteger(value) || value < 0) {
+    return createFailure("invalid_request", "expectedRevision must be a non-negative integer.");
+  }
+  return { ok: true, value };
+}
+function canDefaultExpectedRevision(source) {
+  return isTrustedHostMutationSource(source);
+}
+function resolveExpectedRevision(selectedRevision, providedRevision, source) {
+  if (providedRevision === void 0) {
+    if (!canDefaultExpectedRevision(source)) {
+      return createFailure("invalid_request", "expectedRevision must be a non-negative integer.");
+    }
+    return { ok: true, value: selectedRevision };
+  }
+  return normalizeExpectedRevision(providedRevision);
+}
+function validateWorkingBudgetState(budget) {
+  const entries = [
+    ["tokenBudget", budget.tokenBudget],
+    ["tokenUsed", budget.tokenUsed],
+    ["wallClockBudgetSeconds", budget.wallClockBudgetSeconds],
+    ["wallClockUsedSeconds", budget.wallClockUsedSeconds],
+    ["turnBudget", budget.turnBudget],
+    ["turnsUsed", budget.turnsUsed],
+    ["requireReviewAfterSeconds", budget.requireReviewAfterSeconds]
+  ];
+  for (const [key, value] of entries) {
+    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
+      return createFailure("invalid_request", `${key} must be a non-negative finite number.`);
+    }
+  }
+  return { ok: true };
+}
+function validateWorkingUsageDelta(usage) {
+  const entries = [
+    ["tokenDelta", usage.tokenDelta],
+    ["wallClockSecondsDelta", usage.wallClockSecondsDelta],
+    ["turnDelta", usage.turnDelta]
+  ];
+  const hasDelta = entries.some(([, value]) => value !== void 0);
+  if (!hasDelta) {
+    return createFailure("invalid_request", "account_usage requires at least one usage delta.");
+  }
+  for (const [key, value] of entries) {
+    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
+      return createFailure("invalid_request", `${key} must be a non-negative finite number.`);
+    }
+  }
+  return { ok: true };
+}
+
+// src/app/working-memory/handlers/close.ts
+async function handleClose(params, repository, timestamp) {
+  if (!isTrustedHostMutationSource(params.source)) {
+    return createFailure(
+      "close_not_allowed",
+      "agenr_work close is reserved for /goal clear. Record progress with merge_checkpoint and leave the working set open."
+    );
+  }
+  const closeReason = normalizeRequiredString(params.closeReason, "agenr_work close requires closeReason.");
+  if (!closeReason.ok) {
+    return closeReason;
+  }
+  const selection = await selectWorkingSet(params, repository);
+  if (!selection.ok) {
+    return selection;
+  }
+  const expectedRevision = resolveExpectedRevision(selection.workingSet.revision, params.expectedRevision, params.source);
+  if (!expectedRevision.ok) {
+    return expectedRevision;
+  }
+  if (isCloseManagedStatus(selection.workingSet.status)) {
+    return createFailure("terminal_status", `Working set ${selection.workingSet.id} is already ${selection.workingSet.status}.`, {
+      workingSetId: selection.workingSet.id,
+      status: selection.workingSet.status
+    });
+  }
+  const events = await repository.listWorkingEvents(selection.workingSet.id, CLOSE_EVENT_HISTORY_LIMIT);
+  const terminalStatus = resolveCloseTerminalStatus(params.closeMode);
+  const closePayload = buildWorkingCloseSnapshot({
+    workingSetId: selection.workingSet.id,
+    snapshot: selection.workingSet.snapshot,
+    currentRevision: selection.workingSet.revision,
+    closeReason: closeReason.value,
+    createEpisode: params.createEpisode,
+    eventSequences: events.map((event) => event.sequence),
+    now: timestamp
+  });
+  const writeResult = await repository.updateWorkingSet({
+    workingSetId: selection.workingSet.id,
+    expectedRevision: expectedRevision.value,
+    eventType: terminalStatus,
+    payload: {
+      closeReason: closeReason.value,
+      closeMode: params.closeMode ?? "close",
+      candidates: closePayload.candidates,
+      sourceRef: `working_set:${selection.workingSet.id}#rev:${selection.workingSet.revision}`
+    },
+    status: terminalStatus,
+    snapshot: closePayload.snapshot,
+    title: selection.workingSet.title,
+    objective: selection.workingSet.snapshot.objective,
+    closedAt: timestamp,
+    closeReason: closeReason.value,
+    actor: params.actor,
+    source: params.source,
+    now: timestamp
+  });
+  return toCloseResult(selection.workingSet.id, writeResult, closePayload.candidates);
+}
+function toCloseResult(workingSetId, writeResult, candidates) {
+  if (isWorkingSetWriteFailure(writeResult)) {
+    return writeFailureToResult(workingSetId, writeResult);
+  }
+  return {
+    ok: true,
+    action: "close",
+    workingSet: writeResult.workingSet,
+    event: writeResult.event,
+    candidates
+  };
+}
+
+// src/app/working-memory/resolve-create-scope.ts
+async function resolveCreateScope(params, repository) {
+  const workingSetId = params.workingSetId?.trim();
+  if (workingSetId) {
+    const workingSet = await repository.getWorkingSet(workingSetId);
+    if (workingSet) {
+      return createFailure("active_set_exists", "A working set is already active for this scope.", {
+        workingSetId: workingSet.id,
+        scopeKey: workingSet.scopeKey
+      });
+    }
+    return createFailure("not_found", `Working set ${workingSetId} was not found.`, { workingSetId });
+  }
+  const lookup = await lookupCurrentWorkingSets(params.scope, repository);
+  if (!lookup.ok) {
+    return lookup;
+  }
+  if (lookup.matches.length === 1) {
+    const existing = lookup.matches[0];
+    return createFailure("active_set_exists", "A working set already exists for this scope.", {
+      workingSetId: existing.id,
+      scopeKey: lookup.scope.scopeKey
+    });
+  }
+  return {
+    ok: true,
+    scope: lookup.scope
+  };
+}
+
+// src/app/working-memory/handlers/create.ts
+async function handleCreate(params, repository, timestamp, sourceLabel) {
+  const operation = params.operation;
+  if (!operation || operation.type !== "set_objective") {
+    return createFailure("invalid_request", "agenr_work create requires a set_objective operation.");
+  }
+  const updateReason = normalizeRequiredString(params.updateReason, "agenr_work create requires updateReason.");
+  if (!updateReason.ok) {
+    return updateReason;
+  }
+  const scopeResolution = await resolveCreateScope(params, repository);
+  if (!scopeResolution.ok) {
+    return scopeResolution;
+  }
+  const { scope } = scopeResolution;
+  const initialBudget = params.initialBudget ? validateWorkingBudgetState(params.initialBudget) : { ok: true };
+  if (!initialBudget.ok) {
+    return initialBudget;
+  }
+  const created = await repository.createWorkingSet({
+    scope,
+    title: operation.title,
+    objective: operation.objective,
+    status: "active",
+    snapshot: {
+      goalGeneration: INITIAL_GOAL_GENERATION,
+      objective: operation.objective,
+      continuation: { policy: params.continuationPolicy ?? "manual" },
+      ...params.initialBudget ? { budgets: params.initialBudget } : {},
+      lastMaterialChange: updateReason.value
+    },
+    actor: params.actor,
+    source: params.source,
+    sourceLabel,
+    sessionId: scope.sessionId,
+    now: timestamp
+  });
+  if (isWorkingSetCreateFailure(created)) {
+    return createFailure("active_set_exists", "A working set already exists for this scope.", {
+      scopeKey: created.scopeKey
+    });
+  }
+  return {
+    ok: true,
+    action: "create",
+    workingSet: created.workingSet,
+    event: created.event,
+    projection: createToolSuccessProjection(created.workingSet, "create", timestamp)
+  };
+}
+
+// src/app/working-memory/handlers/get.ts
+async function handleGet(params, repository, timestamp) {
+  const selection = await selectWorkingSet(params, repository);
+  if (!selection.ok) {
+    return selection;
+  }
+  const events = params.includeEvents ? await repository.listWorkingEvents(selection.workingSet.id, normalizeEventLimit(params.eventLimit)) : void 0;
+  return {
+    ok: true,
+    action: "get",
+    workingSet: selection.workingSet,
+    ...events ? { events } : {},
+    projection: createToolSuccessProjection(selection.workingSet, "get", timestamp)
+  };
+}
+
+// src/app/working-memory/handlers/list.ts
+async function handleList(params, repository) {
+  const scopeResolution = params.scope ? resolveWorkingScope(params.scope) : void 0;
+  if (scopeResolution && !scopeResolution.ok) {
+    return createFailure("missing_scope", scopeResolution.message);
+  }
+  const workingSets = await repository.listWorkingSets({
+    ...scopeResolution?.ok ? { scope: scopeResolution.scope } : {},
+    limit: normalizeListLimit(params.listLimit)
+  });
+  return {
+    ok: true,
+    action: "list",
+    workingSets
+  };
+}
+
+// src/app/working-memory/apply-operation.ts
+function applyOperation(record, operation, updateReason) {
+  const snapshot = { ...record.snapshot, lastMaterialChange: updateReason };
+  let status = record.status;
+  let title = record.title;
+  let objective = record.snapshot.objective;
+  switch (operation.type) {
+    case "set_objective":
+      snapshot.goalGeneration = nextGoalGenerationAfterObjectiveChange(snapshot, operation.objective);
+      snapshot.objective = operation.objective;
+      objective = operation.objective;
+      title = operation.title ?? title;
+      break;
+    case "replace_plan":
+      snapshot.currentPlan = operation.currentPlan;
+      snapshot.nextActions = operation.nextActions;
+      break;
+    case "merge_checkpoint":
+      snapshot.checkpoint = operation.checkpoint;
+      if (operation.checkpoint.nextActions) {
+        snapshot.nextActions = operation.checkpoint.nextActions.map((text) => ({ text, status: "pending" }));
+      }
+      if (operation.checkpoint.blockers) {
+        snapshot.blockers = operation.checkpoint.blockers;
+      }
+      break;
+    case "add_file_note":
+      snapshot.files = [...snapshot.files ?? [], operation.file];
+      break;
+    case "add_command_note":
+      snapshot.commands = [...snapshot.commands ?? [], operation.command];
+      break;
+    case "record_decision":
+      snapshot.decisions = [...snapshot.decisions ?? [], operation.decision];
+      break;
+    case "record_assumption":
+      snapshot.assumptions = [...snapshot.assumptions ?? [], operation.assumption];
+      break;
+    case "set_next_actions":
+      snapshot.nextActions = operation.nextActions;
+      break;
+    case "set_status":
+      if (isCloseManagedStatus(operation.status)) {
+        return createFailure("invalid_request", "Use agenr_work close for closed or abandoned terminal states.");
+      }
+      status = operation.status;
+      break;
+    case "add_candidate":
+      snapshot.candidates = [...snapshot.candidates ?? [], operation.candidate];
+      break;
+    case "configure_budget": {
+      const budget = mergeBudgetState(snapshot.budgets, operation.budget);
+      if (!budget.ok) {
+        return budget;
+      }
+      const limited = applyBudgetLimitedStatus(status, budget.value, updateReason);
+      snapshot.budgets = limited.budgets;
+      status = limited.status;
+      break;
+    }
+    case "account_usage": {
+      const budget = applyUsageDelta(snapshot.budgets, operation.usage, updateReason);
+      if (!budget.ok) {
+        return budget;
+      }
+      const limited = applyBudgetLimitedStatus(status, budget.value, operation.usage.recordedAt ?? updateReason);
+      snapshot.budgets = limited.budgets;
+      status = limited.status;
+      break;
+    }
+    case "set_continuation_policy":
+      snapshot.continuation = pruneContinuation({
+        ...snapshot.continuation,
+        policy: operation.policy,
+        ...operation.resumeAfter !== void 0 ? { resumeAfter: operation.resumeAfter } : {},
+        ...operation.staleAfter !== void 0 ? { staleAfter: operation.staleAfter } : {},
+        ...operation.stopReason !== void 0 ? { stopReason: operation.stopReason } : {}
+      });
+      break;
+  }
+  return {
+    ok: true,
+    snapshot,
+    status,
+    title,
+    objective
+  };
+}
+function mergeBudgetState(current, update) {
+  const validation = validateWorkingBudgetState(update);
+  if (!validation.ok) {
+    return validation;
+  }
+  return {
+    ok: true,
+    value: pruneBudget({
+      ...current ?? {},
+      ...update
+    })
+  };
+}
+function applyUsageDelta(current, usage, limitedAt) {
+  const validation = validateWorkingUsageDelta(usage);
+  if (!validation.ok) {
+    return validation;
+  }
+  const next = {
+    ...current ?? {},
+    tokenUsed: addDelta(current?.tokenUsed, usage.tokenDelta),
+    wallClockUsedSeconds: addDelta(current?.wallClockUsedSeconds, usage.wallClockSecondsDelta),
+    turnsUsed: addDelta(current?.turnsUsed, usage.turnDelta)
+  };
+  const limitReason = resolveBudgetLimitReason(next);
+  return {
+    ok: true,
+    value: pruneBudget({
+      ...next,
+      ...limitReason ? { limitReason, limitedAt: usage.recordedAt ?? limitedAt } : {}
+    })
+  };
+}
+function applyBudgetLimitedStatus(currentStatus, budget, limitedAt) {
+  const limitReason = resolveBudgetLimitReason(budget);
+  if (!limitReason || !budget) {
+    return { status: currentStatus, budgets: budget };
+  }
+  return {
+    status: "budget_limited",
+    budgets: pruneBudget({
+      ...budget,
+      limitReason: budget.limitReason ?? limitReason,
+      limitedAt: budget.limitedAt ?? limitedAt
+    })
+  };
+}
+function resolveBudgetLimitReason(budget) {
+  if (!budget) {
+    return void 0;
+  }
+  if (budget.tokenBudget !== void 0 && (budget.tokenUsed ?? 0) >= budget.tokenBudget) {
+    return "token";
+  }
+  if (budget.wallClockBudgetSeconds !== void 0 && (budget.wallClockUsedSeconds ?? 0) >= budget.wallClockBudgetSeconds) {
+    return "wall_clock";
+  }
+  if (budget.turnBudget !== void 0 && (budget.turnsUsed ?? 0) >= budget.turnBudget) {
+    return "turn";
+  }
+  return void 0;
+}
+function addDelta(current, delta) {
+  if (delta === void 0) {
+    return current;
+  }
+  return (current ?? 0) + delta;
+}
+function pruneBudget(budget) {
+  return Object.fromEntries(Object.entries(budget).filter(([, value]) => value !== void 0));
+}
+function pruneContinuation(continuation) {
+  if (!continuation) {
+    return void 0;
+  }
+  const pruned = Object.fromEntries(Object.entries(continuation).filter(([, value]) => value !== void 0));
+  return Object.keys(pruned).length > 0 ? pruned : void 0;
+}
+
+// src/app/working-memory/handlers/commit-applied-change.ts
+function isAppliedWorkingSetCommitFailure(result) {
+  return "kind" in result;
+}
+async function commitAppliedWorkingSetChange(repository, input) {
+  if (input.operation.type === "account_usage") {
+    const writeResult2 = await repository.patchWorkingSetUsage({
+      workingSetId: input.workingSetId,
+      expectedRevision: input.expectedRevision,
+      status: input.applied.status,
+      snapshot: input.applied.snapshot,
+      title: input.applied.title,
+      objective: input.applied.objective,
+      now: input.now
+    });
+    if (isWorkingSetWriteFailure(writeResult2)) {
+      return writeResult2;
+    }
+    return {
+      type: "usage_patch",
+      workingSet: writeResult2.workingSet
+    };
+  }
+  const writeResult = await repository.updateWorkingSet({
+    workingSetId: input.workingSetId,
+    expectedRevision: input.expectedRevision,
+    eventType: input.operation.type,
+    payload: {
+      operation: input.operation,
+      updateReason: input.updateReason
+    },
+    status: input.applied.status,
+    snapshot: input.applied.snapshot,
+    title: input.applied.title,
+    objective: input.applied.objective,
+    actor: input.actor,
+    source: input.source,
+    now: input.now
+  });
+  if (isWorkingSetWriteFailure(writeResult)) {
+    return writeResult;
+  }
+  return {
+    type: "semantic",
+    workingSet: writeResult.workingSet,
+    event: writeResult.event
+  };
+}
+
+// src/app/working-memory/handlers/prepare-external-mutation.ts
+async function handlePrepareExternalGoalMutation(params, repository, timestamp) {
+  if (!isTrustedHostMutationSource(params.source)) {
+    return createFailure("invalid_request", "prepare_external_goal_mutation is reserved for trusted host runtime paths.");
+  }
+  const selection = await selectWorkingSet(params, repository);
+  if (!selection.ok) {
+    if (selection.code === "missing_active_set") {
+      return {
+        ok: true,
+        action: "prepare_external_goal_mutation",
+        prepared: false,
+        events: []
+      };
+    }
+    return selection;
+  }
+  if (params.requireCheckpoint && !params.checkpoint && !selection.workingSet.snapshot.checkpoint) {
+    return createFailure("invalid_request", `Active goal requires a checkpoint before ${params.mutationKind}.`, {
+      workingSetId: selection.workingSet.id,
+      revision: selection.workingSet.revision,
+      mutationKind: params.mutationKind
+    });
+  }
+  if (!isMutableWorkingSetStatus(selection.workingSet.status)) {
+    return {
+      ok: true,
+      action: "prepare_external_goal_mutation",
+      prepared: true,
+      workingSet: selection.workingSet,
+      events: []
+    };
+  }
+  const events = [];
+  let workingSet = selection.workingSet;
+  for (const { operation, updateReason } of resolvePrepareOperations(params)) {
+    const applied = applyOperation(workingSet, operation, updateReason);
+    if (!applied.ok) {
+      return applied;
+    }
+    const writeResult = await commitAppliedWorkingSetChange(repository, {
+      workingSetId: workingSet.id,
+      expectedRevision: workingSet.revision,
+      operation,
+      updateReason,
+      applied,
+      actor: params.actor,
+      source: params.source,
+      now: timestamp
+    });
+    if (isAppliedWorkingSetCommitFailure(writeResult)) {
+      return writeFailureToResult(workingSet.id, writeResult);
+    }
+    workingSet = writeResult.workingSet;
+    if (writeResult.type === "semantic") {
+      events.push(writeResult.event);
+    }
+  }
+  return {
+    ok: true,
+    action: "prepare_external_goal_mutation",
+    prepared: true,
+    workingSet,
+    events
+  };
+}
+function resolvePrepareOperations(params) {
+  const operations = [];
+  if (params.usage) {
+    operations.push({
+      operation: { type: "account_usage", usage: params.usage },
+      updateReason: params.updateReason ?? `Accounted progress before external goal mutation (${params.mutationKind}).`
+    });
+  }
+  if (params.checkpoint) {
+    operations.push({
+      operation: { type: "merge_checkpoint", checkpoint: params.checkpoint },
+      updateReason: params.updateReason ?? `Recorded checkpoint before external goal mutation (${params.mutationKind}).`
+    });
+  }
+  return operations;
+}
+
+// src/app/working-memory/handlers/update.ts
+async function handleUpdate(params, repository, timestamp) {
+  const operation = params.operation;
+  if (!operation) {
+    return createFailure("invalid_request", "agenr_work update requires a typed operation.");
+  }
+  if (isTrustedHostOnlyWorkingOperation(operation.type) && !isTrustedHostMutationSource(params.source)) {
+    return createFailure("invalid_request", `${operation.type} is reserved for trusted host runtime paths.`);
+  }
+  const updateReason = normalizeRequiredString(params.updateReason, "agenr_work update requires updateReason.");
+  if (!updateReason.ok) {
+    return updateReason;
+  }
+  const selection = await selectWorkingSet(params, repository);
+  if (!selection.ok) {
+    return selection;
+  }
+  const expectedRevision = resolveExpectedRevision(selection.workingSet.revision, params.expectedRevision, params.source);
+  if (!expectedRevision.ok) {
+    return expectedRevision;
+  }
+  if (!isMutableWorkingSetStatus(selection.workingSet.status)) {
+    return createFailure("terminal_status", `Working set ${selection.workingSet.id} is already ${selection.workingSet.status}.`, {
+      workingSetId: selection.workingSet.id,
+      status: selection.workingSet.status
+    });
+  }
+  const applied = applyOperation(selection.workingSet, operation, updateReason.value);
+  if (!applied.ok) {
+    return applied;
+  }
+  const writeResult = await commitAppliedWorkingSetChange(repository, {
+    workingSetId: selection.workingSet.id,
+    expectedRevision: expectedRevision.value,
+    operation,
+    updateReason: updateReason.value,
+    applied,
+    actor: params.actor,
+    source: params.source,
+    now: timestamp
+  });
+  if (isAppliedWorkingSetCommitFailure(writeResult)) {
+    return writeFailureToResult(selection.workingSet.id, writeResult);
+  }
+  return {
+    ok: true,
+    action: "update",
+    workingSet: writeResult.workingSet,
+    ...writeResult.type === "semantic" ? { event: writeResult.event } : {},
+    projection: createToolSuccessProjection(writeResult.workingSet, "update", timestamp)
+  };
+}
+
+// src/app/working-memory/service.ts
+function createWorkingMemoryService(featureFlags, deps = {}) {
+  const featureEnabled = featureFlags.workingMemory;
+  const repository = deps.repository;
+  const now = () => deps.now ? deps.now().toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  const readiness = () => workingMemoryNotReadyFailure({ featureEnabled, repository });
+  return {
+    async run(params) {
+      const notReady = readiness();
+      if (notReady) {
+        return notReady;
+      }
+      switch (params.action) {
+        case "get":
+          return handleGet(params, repository, now());
+        case "list":
+          return handleList(params, repository);
+        case "create":
+          return handleCreate(params, repository, now(), deps.sourceLabel);
+        case "update":
+          return handleUpdate(params, repository, now());
+        case "close":
+          return handleClose(params, repository, now());
+      }
+    },
+    async prepareExternalGoalMutation(params) {
+      const notReady = readiness();
+      if (notReady) {
+        return notReady;
+      }
+      return handlePrepareExternalGoalMutation(params, repository, now());
+    },
+    async renderProjection(input) {
+      const request = typeof input === "string" ? { sourceRef: input } : input;
+      if (!featureEnabled) {
+        return createWorkingContextStubProjection({
+          reason: "feature_disabled",
+          sourceRef: request.sourceRef
+        });
+      }
+      if (!repository) {
+        return createWorkingContextStubProjection({
+          reason: "misconfigured",
+          sourceRef: request.sourceRef
+        });
+      }
+      const selection = await selectWorkingSet({ workingSetId: request.workingSetId, scope: request.scope }, repository);
+      if (!selection.ok) {
+        return createWorkingContextStubProjection({
+          reason: selection.code === "ambiguous_scope" ? "ambiguous_scope" : "missing_active_set",
+          sourceRef: request.sourceRef
+        });
+      }
+      return createWorkingContextFullProjection(selection.workingSet, request.sourceRef);
+    }
+  };
+}
+export {
+  WORKING_MEMORY_MISCONFIGURED_MESSAGE,
+  createWorkingMemoryService
+};