@hasna/todos 0.15.20 → 0.15.25

package/dist/server/index.js

@@ -70,7 +70,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.20",
+    version: "0.15.25",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -142,6 +142,8 @@ var init_package = __esm(() => {
       "dev:serve": "bun run src/server/index.ts",
       "verify:release": "bun run scripts/verify-public-release.ts --mode=review",
       "verify:release-review": "bun run scripts/verify-npm-release-agent-review.ts",
+      "verify:attested-container-candidate": "bun run scripts/attested-container-candidate.ts verify",
+      "test:attested-container-candidate": "bun test scripts/attested-container-candidate.test.ts",
       "issue:release-review": "bun run scripts/issue-npm-release-agent-review.ts",
       prepublishOnly: "bun run scripts/verify-public-release.ts --mode=publish",
       postinstall: "mkdir -p $HOME/.hasna/todos $HOME/.hasna/todos/training 2>/dev/null || true"
@@ -194,6 +196,7 @@ var init_package = __esm(() => {
       "@types/bun": "^1.2.4",
       "@types/react": "^18.3.18",
       "bun-types": "1.3.9",
+      "hasna-deployment-contracts": "npm:@hasna/contracts@0.10.4",
       typescript: "^5.7.3"
     }
   };
@@ -1209,7 +1212,7 @@ var init_plan_project_link_contract = __esm(() => {
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join3 } from "path";
 function getConfigPath() {
   return join3(getTodosGlobalDir(), "config.json");
@@ -1586,7 +1589,7 @@ function requireCanonicalLockVersion(value) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must be the exact canonical locked_at timestamp (YYYY-MM-DDTHH:mm:ss.sssZ)", { field: "expected_lock_version" });
   }
   const parsed = Date.parse(value);
-  if (Number.isNaN(parsed) || new Date(parsed).toISOString() !== value) {
+  if (value.startsWith("0000-") || Number.isNaN(parsed) || new Date(parsed).toISOString() !== value) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must name a real canonical UTC instant", { field: "expected_lock_version" });
   }
   return value;
@@ -1611,9 +1614,6 @@ function prepareStaleLockHandoff(input, options = {}) {
   if (canonicalAgentRef(actor) !== canonicalAgentRef(newHolder)) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_ACTOR_MISMATCH", "new_holder must match the authenticated actor", { actor, new_holder: newHolder });
   }
-  if (canonicalAgentRef(expectedHolder) === canonicalAgentRef(newHolder)) {
-    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "new_holder must differ from expected_holder", { field: "new_holder" });
-  }
   const operationTimestamp = options.now ?? new Date().toISOString();
   if (!CANONICAL_LOCK_VERSION_RE.test(operationTimestamp) || new Date(Date.parse(operationTimestamp)).toISOString() !== operationTimestamp) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "operation timestamp must be a canonical UTC instant");
@@ -2421,6 +2421,31 @@ var init_audit_history_import = __esm(() => {
   ];
 });
 
+// src/task-manifest/canonical.ts
+import { createHash as createHash3 } from "crypto";
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize(entry2)]));
+  }
+  return value;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalDigest(value) {
+  return createHash3("sha256").update(canonicalJson(value)).digest("hex");
+}
+function deterministicUuid(namespace, ...parts) {
+  const bytes = createHash3("sha256").update([namespace, ...parts].join("\x1F")).digest().subarray(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+var init_canonical = () => {};
+
 // src/storage/postgres-adapter.ts
 import { randomUUID } from "crypto";
 function createPostgresTodosStorageAdapter(options) {
@@ -2646,7 +2671,7 @@ class PostgresJsonRecordStore {
            AND task_record.deleted_at IS NULL
            AND target.payload->>'locked_by' = $3
            AND target.payload->>'locked_at' = $4
-           AND todos_try_timestamptz(target.payload->>'locked_at') < $5::timestamptz
+           AND $4::timestamptz < $5::timestamptz
            AND COALESCE(target.payload->>'status', '') NOT IN ('completed', 'failed', 'cancelled')
          RETURNING task_record.payload
        ),
@@ -4088,16 +4113,17 @@ async function findCommit(sha, store) {
 async function addGitRef(input, store, context) {
   if (!await store.get("tasks", input.task_id))
     throw new Error(`Task not found: ${input.task_id}`);
+  const existing = (await store.list("refs")).filter((ref) => ref.task_id === input.task_id && ref.ref_type === input.ref_type && ref.name === input.name).sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id))[0];
   const timestamp = new Date().toISOString();
   const gitRef = {
-    id: randomUUID(),
+    id: existing?.id ?? deterministicUuid("todos:git-ref:v1", input.task_id, input.ref_type, input.name),
     task_id: input.task_id,
     ref_type: input.ref_type,
     name: input.name,
-    url: input.url ?? null,
-    provider: input.provider ?? null,
+    url: input.url ?? existing?.url ?? null,
+    provider: input.provider ?? existing?.provider ?? null,
     metadata: input.metadata ?? {},
-    created_at: timestamp,
+    created_at: existing?.created_at ?? timestamp,
     updated_at: timestamp
   };
   await store.upsert("refs", gitRef, context);
@@ -4659,6 +4685,7 @@ var init_postgres_adapter = __esm(() => {
   init_integrity();
   init_redaction();
   init_audit_history_import();
+  init_canonical();
   TASK_ORDER_BY = `ORDER BY ${TASK_ORDER_TIEBREAK}`;
 });
 
@@ -4678,9 +4705,9 @@ var init_types2 = __esm(() => {
 });
 
 // src/pr-groups/ledger.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function stableValue(value) {
   if (Array.isArray(value))
@@ -12117,7 +12144,7 @@ var init_runner_sandbox = __esm(() => {
 });
 
 // src/lib/event-hooks.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname3, resolve as resolve6 } from "path";
 import { createConnection } from "net";
@@ -12184,7 +12211,7 @@ function buildEnvelope(type, payload, timestamp2 = new Date().toISOString()) {
     payload: redactValue(payload ?? {}),
     source: { package: "@hasna/todos", local_only: true }
   };
-  const digest = createHash4("sha256").update(canonicalEvent(base)).digest("hex");
+  const digest = createHash5("sha256").update(canonicalEvent(base)).digest("hex");
   return { ...base, integrity: { algorithm: "sha256", digest } };
 }
 function summarize(value) {
@@ -17194,8 +17221,8 @@ var init_boards = __esm(() => {
 });
 
 // src/lib/artifact-store.ts
-import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename, dirname as dirname4, join as join6, resolve as resolve7 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function isInMemoryDb2(path) {
@@ -17219,7 +17246,7 @@ function artifactStorePath(relativePath) {
   return join6(artifactStoreRoot(), normalized);
 }
 function sha2562(buffer) {
-  return createHash5("sha256").update(buffer).digest("hex");
+  return createHash6("sha256").update(buffer).digest("hex");
 }
 function isTextLike(buffer, path) {
   if (buffer.includes(0))
@@ -17262,7 +17289,7 @@ function storeArtifactContent(input) {
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
     throw new Error(`Artifact path is not a file: ${sanitizePreWriteText(input.path, "artifact.path")}`);
-  const sourceBuffer = readFileSync2(sourcePath);
+  const sourceBuffer = readFileSync3(sourcePath);
   const sourceSha = sha2562(sourceBuffer);
   const textLike = isTextLike(sourceBuffer, input.path);
   let storedBuffer = sourceBuffer;
@@ -17349,7 +17376,7 @@ function verifyStoredArtifact(input) {
       message: "stored artifact content is missing"
     };
   }
-  const buffer = readFileSync2(storedPath);
+  const buffer = readFileSync3(storedPath);
   const actualSha = sha2562(buffer);
   const actualSize = buffer.length;
   const ok = actualSha === store.sha256 && actualSize === store.size_bytes;
@@ -17369,7 +17396,7 @@ function exportStoredArtifactContent(input) {
   const report = verifyStoredArtifact(input);
   if (report.status !== "ok" || !report.relative_path || !report.actual_sha256 || report.actual_size_bytes === null)
     return null;
-  const content = readFileSync2(artifactStorePath(report.relative_path));
+  const content = readFileSync3(artifactStorePath(report.relative_path));
   return {
     artifact_id: input.id,
     sha256: report.actual_sha256,
@@ -20952,25 +20979,25 @@ var init_sqlite = __esm(() => {
 });
 
 // src/project-registration/authority.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function canonicalProjectRegistrationJson(value) {
-  return JSON.stringify(canonicalize(value));
+  return JSON.stringify(canonicalize2(value));
 }
-function canonicalize(value) {
+function canonicalize2(value) {
   if (Array.isArray(value))
-    return value.map(canonicalize);
+    return value.map(canonicalize2);
   if (!value || typeof value !== "object")
     return value;
   const out = {};
   for (const key of Object.keys(value).sort()) {
     const entry2 = value[key];
     if (entry2 !== undefined)
-      out[key] = canonicalize(entry2);
+      out[key] = canonicalize2(entry2);
   }
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash6("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash7("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -21965,31 +21992,6 @@ var init_project_registration = __esm(() => {
   init_types3();
 });
 
-// src/task-manifest/canonical.ts
-import { createHash as createHash7 } from "crypto";
-function canonicalize2(value) {
-  if (Array.isArray(value))
-    return value.map(canonicalize2);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize2(entry2)]));
-  }
-  return value;
-}
-function canonicalJson(value) {
-  return JSON.stringify(canonicalize2(value));
-}
-function canonicalDigest(value) {
-  return createHash7("sha256").update(canonicalJson(value)).digest("hex");
-}
-function deterministicUuid(namespace, ...parts) {
-  const bytes = createHash7("sha256").update([namespace, ...parts].join("\x1F")).digest().subarray(0, 16);
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = bytes.toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-var init_canonical = () => {};
-
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -29638,6 +29640,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             plan_id: { type: "string" },
             assigned_to: { type: "string" },
             agent_id: { type: "string" },
+            created_by: { type: "string" },
             tags: { type: "array", items: { type: "string" } }
           }
         },
@@ -31480,6 +31483,7 @@ var init_openapi = __esm(() => {
       parent_id: { type: "string", nullable: true },
       assigned_to: { type: "string", nullable: true },
       agent_id: { type: "string", nullable: true },
+      created_by: { type: "string", nullable: true },
       reason: { type: "string", nullable: true },
       tags: { type: "array", items: { type: "string" } },
       version: { type: "number" },
@@ -51389,7 +51393,7 @@ var init_token_utils = __esm(() => {
 });
 
 // src/lib/assignee-validation.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join9 } from "path";
 function defaultSeatRosterPath() {
@@ -51397,7 +51401,7 @@ function defaultSeatRosterPath() {
 }
 function loadSeatSlugs(path = defaultSeatRosterPath()) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     const slugs = new Set;
     for (const agent of parsed.agents ?? []) {
       if (typeof agent?.slug === "string" && agent.slug.trim()) {
@@ -65030,8 +65034,12 @@ async function cloudGetTask(client, id) {
   const raw = await client.get("tasks", id);
   return raw == null ? null : unwrapTask(raw);
 }
-async function cloudCreateTask(client, input) {
+async function cloudCreateTask(client, input, verification2 = {}) {
   const expectedParentId = typeof input["parent_id"] === "string" ? input["parent_id"] : null;
+  const expectedCreatedBy = typeof verification2.expectedCreatedBy === "string" && verification2.expectedCreatedBy.trim() ? verification2.expectedCreatedBy : null;
+  if (expectedCreatedBy !== null) {
+    await requireTaskCreatorCapability(client);
+  }
   const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.transport.post("/tasks", input, {
     idempotencyKey: randomUUID4(),
     retry: false
@@ -65040,8 +65048,9 @@ async function cloudCreateTask(client, input) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: configured Todos authority ${remoteAuthorityBase(client)} returned a task create ` + "response without a stored task id; no success row or local SQLite fallback is permitted");
   }
   const persisted = await cloudGetTask(client, created.id);
-  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId) {
-    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + "stored task id and parent_id; no success row or local SQLite fallback is permitted");
+  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId || expectedCreatedBy !== null && persisted.created_by !== expectedCreatedBy) {
+    const creatorDetail = expectedCreatedBy === null ? "" : ` and explicit created_by=${JSON.stringify(expectedCreatedBy)} ` + `(readback ${JSON.stringify(persisted?.created_by ?? null)})`;
+    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + `stored task id and parent_id${creatorDetail}; no success row or local SQLite fallback is permitted`);
   }
   return persisted;
 }
@@ -65062,6 +65071,51 @@ async function cloudTaskAction(client, id, action, body2 = {}) {
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/${action}`, body2);
   return unwrapTask(raw);
 }
+function resolveOpenApiSchema(document, schema2) {
+  if (!schema2 || typeof schema2 !== "object" || Array.isArray(schema2))
+    return null;
+  const value = schema2;
+  if (typeof value["$ref"] !== "string")
+    return value;
+  const reference = value["$ref"];
+  if (!reference.startsWith("#/"))
+    return null;
+  let current = document;
+  for (const segment of reference.slice(2).split("/")) {
+    const key2 = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return null;
+    current = current[key2];
+  }
+  return current && typeof current === "object" && !Array.isArray(current) ? current : null;
+}
+function openApiSchemaProperty(document, schemaName, propertyName) {
+  const schema2 = resolveOpenApiSchema(document, {
+    $ref: `#/components/schemas/${schemaName}`
+  });
+  const properties = schema2?.["properties"];
+  if (!properties || typeof properties !== "object" || Array.isArray(properties))
+    return null;
+  const property = properties[propertyName];
+  return property && typeof property === "object" && !Array.isArray(property) ? property : null;
+}
+async function fetchTaskCreatorCapability(client) {
+  const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
+  const inputProperty = openApiSchemaProperty(document, "CreateTaskInput", "created_by");
+  const outputProperty = openApiSchemaProperty(document, "Task", "created_by");
+  return inputProperty?.["type"] === "string" && outputProperty?.["type"] === "string" && outputProperty?.["nullable"] === true;
+}
+async function requireTaskCreatorCapability(client) {
+  const authority = remoteAuthorityBase(client);
+  let capability = taskCreatorCapabilityCache.get(authority);
+  if (!capability) {
+    capability = fetchTaskCreatorCapability(client);
+    taskCreatorCapabilityCache.set(authority, capability);
+  }
+  if (!await capability) {
+    throw new Error(`REMOTE_CREATED_BY_UNSUPPORTED: configured Todos authority ${authority} does not advertise created_by ` + "on both CreateTaskInput and Task in /v1/openapi.json; no task mutation was sent; deploy a compatible " + "@hasna/todos /v1 server before retrying; local SQLite fallback is disabled");
+  }
+}
 async function cloudGetStats(client) {
   const raw = await requiredRemoteRoute(client, "/v1/stats", () => client.transport.get("/stats"));
   return raw ?? {};
@@ -65257,7 +65311,7 @@ async function cloudResolveTaskListRef(client, ref, projectId) {
     return input.toLowerCase();
   return (await cloudResolveTaskList(client, ref, projectId)).id;
 }
-var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, retryCapabilityCache, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
+var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, retryCapabilityCache, taskCreatorCapabilityCache, gitRefCapabilityCache, remoteCommandCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
 var init_cloud_router = __esm(() => {
   init_storage();
   init_mode();
@@ -65277,7 +65331,9 @@ var init_cloud_router = __esm(() => {
   };
   completionCapabilityCache = new Map;
   retryCapabilityCache = new Map;
+  taskCreatorCapabilityCache = new Map;
   gitRefCapabilityCache = new Map;
+  remoteCommandCapabilityCache = new Map;
   SERVER_MODE_CANDIDATES = ["postgres", "cloud", "self_hosted"];
   PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
   listTagsCapabilityCache = new Map;
@@ -65673,7 +65729,7 @@ var init_task_crud2 = __esm(() => {
 });
 
 // src/lib/project-bootstrap.ts
-import { existsSync as existsSync9, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { basename as basename3, dirname as dirname6, resolve as resolve9 } from "path";
 function safeStat(path) {
   try {
@@ -65707,7 +65763,7 @@ function readPackageJson(path) {
   if (!existsSync9(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync4(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -66269,7 +66325,7 @@ var init_retention_cleanup = __esm(() => {
 });
 
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { basename as basename4, isAbsolute, join as join10, relative as relative3, resolve as resolve10, sep as sep3 } from "path";
 function blankResolution(parsed) {
   return {
@@ -66378,7 +66434,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync5(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync6(absolutePath, "utf-8").split(/\r?\n/).length;
     if (parsed.line < 1 || parsed.line > lineCount) {
       resolution.warnings.push(`line ${parsed.line} is outside the file range 1-${lineCount}`);
       return resolution;
@@ -66431,7 +66487,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync5(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync6(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -70098,7 +70154,7 @@ var init_audit_ledger = __esm(() => {
 });
 
 // src/lib/release-compatibility.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join11, resolve as resolve12 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 function pass(id, message, details) {
@@ -70111,7 +70167,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync6(join11(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync7(join11(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -70492,6 +70548,8 @@ function searchTaskEntities(filters, db) {
   return tasks.filter((task2) => taskMatchesSavedFilters(task2, filters, db)).slice(0, normalizeLimit(filters.limit));
 }
 function searchProjects(filters, db) {
+  if (filters.agent_id)
+    return [];
   const params = [];
   let sql = "SELECT * FROM projects WHERE 1=1";
   if (filters.project_id) {
@@ -100034,7 +100092,7 @@ var init_agent_run_dispatcher = __esm(() => {
 });
 
 // src/lib/verification-providers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 function normalizeName5(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -100186,7 +100244,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync7(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync8(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -102927,7 +102985,7 @@ var init_local_bridge = __esm(() => {
 
 // src/lib/local-backups.ts
 import { createHash as createHash12 } from "crypto";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7, resolve as resolve13 } from "path";
 import { mkdirSync as mkdirSync6 } from "fs";
 function stableJson2(value) {
@@ -103037,7 +103095,7 @@ function writeLocalBackupFile(backup, outputPath) {
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync8(resolve13(path), "utf-8"));
+  return JSON.parse(readFileSync9(resolve13(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -104488,7 +104546,7 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash15, createVerify } from "crypto";
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import { basename as basename5, join as join12, resolve as resolve14 } from "path";
 function isObject3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -104570,7 +104628,7 @@ function normalizeManifest(input) {
   };
 }
 function parseJson2(path) {
-  return JSON.parse(readFileSync9(path, "utf8"));
+  return JSON.parse(readFileSync10(path, "utf8"));
 }
 function sha2566(bytes) {
   return `sha256:${createHash15("sha256").update(bytes).digest("hex")}`;
@@ -104754,7 +104812,7 @@ function inspectExtensionSource(source3) {
   const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync13) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source3} is missing todos.extension.json`);
-  const raw = readFileSync9(manifestPath);
+  const raw = readFileSync10(manifestPath);
   const parsed = parseJson2(manifestPath);
   const bundle = isObject3(parsed) && isObject3(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -109267,7 +109325,7 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
 import { createHash as createHash17 } from "crypto";
 import { relative as relative5, resolve as resolve15, join as join13 } from "path";
 function stableHash(value) {
@@ -109282,7 +109340,7 @@ function readGitignorePatterns(basePath) {
   if (!existsSync14(gitignorePath))
     return [];
   try {
-    return readFileSync10(gitignorePath, "utf-8").split(`
+    return readFileSync11(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -109423,7 +109481,7 @@ function buildCodebaseIndex(options) {
   for (const file of files) {
     const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync10(fullPath, "utf-8");
+      const source3 = readFileSync11(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
@@ -109454,7 +109512,7 @@ function extractTodos(options, db) {
   for (const file of files) {
     const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync10(fullPath, "utf-8");
+      const source3 = readFileSync11(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source3, relPath, tags);
       allComments.push(...comments);
@@ -110996,7 +111054,7 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash18 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
 import { dirname as dirname8, join as join15, resolve as resolve16 } from "path";
 import { tmpdir as tmpdir3 } from "os";
@@ -111010,7 +111068,7 @@ function fileRecord(root, relativePath) {
   const stat = statSync8(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync11(path);
+  const content = readFileSync12(path);
   return { path: relativePath, sha256: sha2567(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {

package/dist/server/openapi.d.ts

@@ -53,6 +53,10 @@ export declare function buildV1OpenApiDocument(version?: string): {
                         readonly type: "string";
                         readonly nullable: true;
                     };
+                    readonly created_by: {
+                        readonly type: "string";
+                        readonly nullable: true;
+                    };
                     readonly reason: {
                         readonly type: "string";
                         readonly nullable: true;
@@ -913,6 +917,9 @@ export declare function buildV1OpenApiDocument(version?: string): {
                     agent_id: {
                         type: string;
                     };
+                    created_by: {
+                        type: string;
+                    };
                     tags: {
                         type: string;
                         items: {

package/dist/server/openapi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AAmbA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmoDnE"}
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AAobA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAooDnE"}

package/dist/storage/postgres-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-adapter.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-adapter.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAcV,mBAAmB,EAYpB,MAAM,iBAAiB,CAAC;AAczB,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AA0B5B,MAAM,WAAW,wCAAwC;IACvD,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAuBD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,mBAAmB,CA4JrB"}
+{"version":3,"file":"postgres-adapter.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-adapter.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAcV,mBAAmB,EAYpB,MAAM,iBAAiB,CAAC;AAczB,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AA2B5B,MAAM,WAAW,wCAAwC;IACvD,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAuBD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,mBAAmB,CA4JrB"}