@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/chunk-NSLTJBUC.js

@@ -0,0 +1,270 @@
+// src/app/working-memory/projection-render.ts
+var UTF8_BYTE_LENGTH = new TextEncoder();
+function byteLength(content) {
+  return UTF8_BYTE_LENGTH.encode(content).length;
+}
+function createWorkingContextStubProjection(input) {
+  const content = [
+    "<agenr_work_context>",
+    "Working memory is unavailable for this turn.",
+    `Reason: ${input.reason}`,
+    "Treat this as transient task-state metadata, not durable truth.",
+    "</agenr_work_context>"
+  ].join("\n");
+  return {
+    kind: "working_set",
+    renderMode: "stub",
+    content,
+    ...input.workingSetId ? { workingSetId: input.workingSetId } : {},
+    ...input.revision !== void 0 ? { revision: input.revision } : {},
+    sourceRef: input.sourceRef,
+    byteLength: byteLength(content)
+  };
+}
+function createWorkingContextFullProjection(workingSet, sourceRef) {
+  const snapshot = workingSet.snapshot;
+  const lines = [
+    "<agenr_work_context>",
+    "This is transient working memory for the current task, not durable truth.",
+    "It may be stale or hypothetical. Prefer current filesystem, git, tests, tool output, and the user's latest message for current-state claims.",
+    "",
+    `Scope: ${escapeText(workingSet.scopeKind)} ${escapeText(workingSet.scopeKey)}`,
+    `Working set: ${escapeText(workingSet.id)}`,
+    `Revision: ${workingSet.revision}`,
+    `Status: ${escapeText(workingSet.status)}`,
+    ...optionalLine("Objective", snapshot.objective ?? workingSet.title),
+    ...optionalLine("Summary", snapshot.summary),
+    ...renderStringList("Current plan", snapshot.currentPlan),
+    ...renderCheckpoint(snapshot.checkpoint?.summary),
+    ...renderNextActions(snapshot.nextActions),
+    ...renderLabeledNotes(
+      "Touched files",
+      snapshot.files,
+      (file) => file.path.trim().length > 0,
+      (file) => {
+        const note = file.note ? ` - ${escapeText(file.note)}` : "";
+        return `${escapeText(file.path)}${note}`;
+      }
+    ),
+    ...renderLabeledNotes(
+      "Recent commands",
+      snapshot.commands,
+      (command) => command.command.trim().length > 0,
+      (command) => {
+        const outcome = command.outcome ? ` - ${escapeText(command.outcome)}` : "";
+        return `${escapeText(command.command)}${outcome}`;
+      }
+    ),
+    ...renderLabeledNotes(
+      "Decisions",
+      snapshot.decisions,
+      (decision) => decision.decision.trim().length > 0,
+      (decision) => {
+        const rationale = decision.rationale ? ` - ${escapeText(decision.rationale)}` : "";
+        return `${escapeText(decision.decision)}${rationale}`;
+      }
+    ),
+    ...renderLabeledNotes(
+      "Assumptions",
+      snapshot.assumptions,
+      (assumption) => assumption.assumption.trim().length > 0,
+      (assumption) => {
+        const confidence = assumption.confidence ? ` [${assumption.confidence}]` : "";
+        const validated = assumption.validated === true ? " (validated)" : assumption.validated === false ? " (unvalidated)" : "";
+        return `${escapeText(assumption.assumption)}${confidence}${validated}`;
+      }
+    ),
+    ...renderStringList("Blockers", snapshot.blockers),
+    ...renderStringList("Open questions", snapshot.openQuestions),
+    ...renderCandidates(snapshot.candidates),
+    "",
+    "Rules:",
+    "- Update this working set when material task state changes.",
+    "- Leave a checkpoint before pausing, handing off, compacting, forking, or waiting.",
+    "- Do not close this working set; only the user clears goals with /goal clear.",
+    "- Do not store transient WIP with agenr_store.",
+    "- Promote only durable facts, decisions, preferences, or reusable procedures explicitly.",
+    "</agenr_work_context>"
+  ];
+  const content = lines.join("\n");
+  return {
+    kind: "working_set",
+    renderMode: "full",
+    content,
+    workingSetId: workingSet.id,
+    revision: workingSet.revision,
+    sourceRef,
+    byteLength: byteLength(content)
+  };
+}
+function escapeText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function optionalLine(label, value) {
+  const normalized = value?.trim();
+  return normalized ? [`${label}: ${escapeText(normalized)}`] : [];
+}
+function renderStringList(title, values) {
+  const items = (values ?? []).map((value) => value.trim()).filter((value) => value.length > 0);
+  if (items.length === 0) {
+    return [];
+  }
+  return ["", `${title}:`, ...items.map((item) => `- ${escapeText(item)}`)];
+}
+function renderCheckpoint(summary) {
+  const normalized = summary?.trim();
+  return normalized ? ["", "Last checkpoint:", escapeText(normalized)] : [];
+}
+function renderLabeledNotes(title, items, isValid, formatLine) {
+  const filtered = (items ?? []).filter(isValid);
+  if (filtered.length === 0) {
+    return [];
+  }
+  return ["", `${title}:`, ...filtered.map((item) => `- ${formatLine(item)}`)];
+}
+function renderNextActions(actions) {
+  const items = (actions ?? []).filter((action) => action.text.trim().length > 0);
+  if (items.length === 0) {
+    return [];
+  }
+  return [
+    "",
+    "Next actions:",
+    ...items.map((action) => {
+      const status = action.status ? ` [${action.status}]` : "";
+      const ref = action.ref ? ` (${escapeText(action.ref)})` : "";
+      return `- ${escapeText(action.text)}${status}${ref}`;
+    })
+  ];
+}
+function renderCandidates(candidates) {
+  const pending = (candidates ?? []).filter((candidate) => candidate.promotionStatus === "pending");
+  if (pending.length === 0) {
+    return [];
+  }
+  return [
+    "",
+    "Pending memory candidates:",
+    ...pending.map((candidate) => {
+      if (candidate.kind === "episodic") {
+        return `- episodic: ${escapeText(candidate.summary)}`;
+      }
+      return `- ${candidate.kind}: ${escapeText(candidate.subject)}`;
+    })
+  ];
+}
+
+// src/app/working-memory/results.ts
+function createFailure(code, message, details) {
+  return {
+    ok: false,
+    code,
+    message,
+    ...details ? { details } : {}
+  };
+}
+function writeFailureToResult(workingSetId, failure) {
+  switch (failure.kind) {
+    case "not_found":
+      return createFailure("not_found", "Working set was not found.", workingSetId ? { workingSetId } : void 0);
+    case "revision_conflict":
+      return createFailure("revision_conflict", "Working-set revision conflict.", {
+        actualRevision: failure.actualRevision,
+        ...workingSetId ? { workingSetId } : {}
+      });
+    case "terminal_status":
+      return createFailure("terminal_status", `Working set is already ${failure.status}.`, {
+        status: failure.status,
+        ...workingSetId ? { workingSetId } : {}
+      });
+  }
+}
+
+// src/app/working-memory/ready.ts
+var WORKING_MEMORY_DISABLED_MESSAGE = "Working memory is disabled by the workingMemory feature flag.";
+var WORKING_MEMORY_MISCONFIGURED_MESSAGE = "Working memory is enabled, but no working-memory repository was wired into the runtime.";
+function workingMemoryNotReadyFailure(input) {
+  if (!input.featureEnabled) {
+    return createFailure("feature_disabled", WORKING_MEMORY_DISABLED_MESSAGE);
+  }
+  if (!input.repository) {
+    return createFailure("misconfigured", WORKING_MEMORY_MISCONFIGURED_MESSAGE);
+  }
+  return null;
+}
+
+// src/app/working-memory/limits.ts
+function normalizeBoundedLimit(value, fallback, max) {
+  if (value === void 0 || !Number.isInteger(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.min(value, max);
+}
+function normalizeEventLimit(value) {
+  return normalizeBoundedLimit(value, 50, 200);
+}
+function normalizeListLimit(value) {
+  return normalizeBoundedLimit(value, 20, 100);
+}
+var CLOSE_EVENT_HISTORY_LIMIT = 1e3;
+
+// src/app/working-memory/operations/manifest.ts
+var MODEL_VISIBLE_OPERATION_TYPES = [
+  "set_objective",
+  "replace_plan",
+  "merge_checkpoint",
+  "add_file_note",
+  "add_command_note",
+  "record_decision",
+  "record_assumption",
+  "set_next_actions",
+  "add_candidate"
+];
+var TRUSTED_HOST_ONLY_OPERATION_TYPES = ["configure_budget", "account_usage", "set_continuation_policy"];
+var HOST_ONLY_OPERATION_TYPES = ["set_status", ...TRUSTED_HOST_ONLY_OPERATION_TYPES];
+var WORKING_UPDATE_OPERATION_TYPES = [...MODEL_VISIBLE_OPERATION_TYPES, ...HOST_ONLY_OPERATION_TYPES];
+function isModelVisibleOperationType(type) {
+  return MODEL_VISIBLE_OPERATION_TYPES.includes(type);
+}
+function isTrustedHostOnlyWorkingOperation(type) {
+  return TRUSTED_HOST_ONLY_OPERATION_TYPES.includes(type);
+}
+
+// src/app/working-memory/constants.ts
+var OPEN_WORKING_SET_STATUSES = ["active", "paused", "blocked", "waiting", "needs_review", "budget_limited"];
+var CURRENT_WORKING_SET_STATUSES = [...OPEN_WORKING_SET_STATUSES, "complete"];
+var CLOSE_MANAGED_WORKING_SET_STATUSES = ["closed", "abandoned"];
+var TRUSTED_HOST_MUTATION_SOURCES = ["goal_command", "lifecycle_hook", "consolidation_job"];
+var WORKING_CANDIDATE_PROMOTION_STATUSES = ["pending", "promoted", "dismissed"];
+function isMutableWorkingSetStatus(status) {
+  return OPEN_WORKING_SET_STATUSES.includes(status);
+}
+function isCloseManagedStatus(status) {
+  return CLOSE_MANAGED_WORKING_SET_STATUSES.includes(status);
+}
+function isTrustedHostMutationSource(source) {
+  return source !== void 0 && TRUSTED_HOST_MUTATION_SOURCES.includes(source);
+}
+
+export {
+  createWorkingContextStubProjection,
+  createWorkingContextFullProjection,
+  normalizeBoundedLimit,
+  normalizeEventLimit,
+  normalizeListLimit,
+  CLOSE_EVENT_HISTORY_LIMIT,
+  isModelVisibleOperationType,
+  isTrustedHostOnlyWorkingOperation,
+  OPEN_WORKING_SET_STATUSES,
+  CURRENT_WORKING_SET_STATUSES,
+  CLOSE_MANAGED_WORKING_SET_STATUSES,
+  WORKING_CANDIDATE_PROMOTION_STATUSES,
+  isMutableWorkingSetStatus,
+  isCloseManagedStatus,
+  isTrustedHostMutationSource,
+  createFailure,
+  writeFailureToResult,
+  WORKING_MEMORY_DISABLED_MESSAGE,
+  WORKING_MEMORY_MISCONFIGURED_MESSAGE,
+  workingMemoryNotReadyFailure
+};

package/dist/chunk-OJSIZDZD.js

@@ -0,0 +1,9 @@
+// src/app/session-memory/normalize.ts
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+
+export {
+  normalizeOptionalString
+};

package/dist/chunk-OWGQWQUP.js

@@ -0,0 +1,45 @@
+import {
+  createWorkingContextFullProjection
+} from "./chunk-NSLTJBUC.js";
+
+// src/app/working-memory/projection.ts
+function createToolSuccessProjection(workingSet, action, timestamp) {
+  return createWorkingContextFullProjection(workingSet, `agenr_work:${action}:${timestamp}`);
+}
+function shouldInjectWorkingContext(projection) {
+  return projection.renderMode === "full" && projection.content.trim().length > 0;
+}
+function toWorkingContextAuditPointer(projection) {
+  if (projection.workingSetId === void 0 || projection.revision === void 0) {
+    return void 0;
+  }
+  return {
+    source: "agenr_work",
+    workingSetId: projection.workingSetId,
+    revision: projection.revision,
+    sourceRef: projection.sourceRef,
+    bytes: projection.byteLength,
+    summary: projection.renderMode === "full" ? `Working set ${projection.workingSetId} rev ${projection.revision}` : `Working memory stub (${projection.sourceRef})`
+  };
+}
+
+// src/app/working-memory/goal-generation.ts
+var INITIAL_GOAL_GENERATION = 1;
+function readGoalGeneration(snapshot) {
+  return snapshot?.goalGeneration ?? INITIAL_GOAL_GENERATION;
+}
+function nextGoalGenerationAfterObjectiveChange(snapshot, nextObjective) {
+  if (snapshot.objective === nextObjective) {
+    return readGoalGeneration(snapshot);
+  }
+  return readGoalGeneration(snapshot) + 1;
+}
+
+export {
+  createToolSuccessProjection,
+  shouldInjectWorkingContext,
+  toWorkingContextAuditPointer,
+  INITIAL_GOAL_GENERATION,
+  readGoalGeneration,
+  nextGoalGenerationAfterObjectiveChange
+};