clay-server 5.2.0-beta.4 → 5.2.0-beta.6

package/lib/issues-service.js

@@ -129,25 +129,35 @@ function attachIssuesService(ctx) {
       principal: principal, worktreeOnly: authorization.worktreeOnly };
   }
 
-  function bind(source, isSession) {
+  function bind(source, isSession, canonicalClay) {
     if (!source || typeof source.projectSlug !== "string") return null;
     var initialSlug = source.projectSlug;
     var initialProject = projectFor(initialSlug);
     var initialSession = isSession ? source.session : null;
+    var clayInitial;
+    if (canonicalClay) { try { clayInitial = require("./canonical-clay-record-authority").resolve(source.authority, initialSlug); } catch (error) { return null; } }
     if (!initialProject || (isSession && !initialSession)) return null;
     if (initialSession) provenance.ensureOrigin(initialSession);
-    var initialUserId = initialSession ? initialSession.ownerId || null : source.userId || null;
+    var initialUserId = initialSession ? initialSession.ownerId || null : canonicalClay ? clayInitial.principal.userId || clayInitial.principal.singleUserOwnerId : source.userId || null;
     var initialOrigin = initialSession ? initialSession.sessionOriginId || null : null;
     var initial = bindingState(initialProject, initialSession, initialUserId, initialOrigin);
     if (!initial) return null;
 
     function current() {
       if (projectFor(initialSlug) !== initialProject) throw new Error("This Issues binding is no longer valid.");
+      if (canonicalClay) {
+        var clayLive = require("./canonical-clay-record-authority").resolve(source.authority, initialSlug);
+        if (clayLive.project !== initialProject || clayLive.status.path !== clayInitial.status.path || clayLive.status.projectKnowledgeId !== clayInitial.status.projectKnowledgeId || clayLive.status.changeSetId !== clayInitial.status.changeSetId) throw new Error("Selected Issues context changed.");
+      }
       var live = bindingState(initialProject, initialSession, initialUserId, initialOrigin);
       if (!live) throw new Error("This Issues binding is no longer valid.");
       return live;
     }
 
+    function expected(entry, args) { if (canonicalClay && (!Number.isInteger(args.expectedRevision) || entry.revision !== args.expectedRevision)) throw new Error("Issue revision conflict."); }
+
+    function actor(state) { return canonicalClay ? require("./canonical-clay-record-authority").resolve(source.authority, initialSlug).actor : author(state.user, state.session ? "session" : "user", state.session); }
+
     function visibleIssue(store, ref, state) {
       var result = store.read(ref);
       if (state.worktreeOnly && (!result.context || result.context.changeSetId !== state.status.changeSetId)) throw new Error("Issue not found.");
@@ -174,7 +184,7 @@ function attachIssuesService(ctx) {
         path: state.status.path, knowledgeId: governing.projectKnowledgeId,
         changeSetId: state.status.changeSetId || null, worktreeOnly: state.worktreeOnly,
         recordContext: clone(issueContext(state.status)),
-        actor: clone(author(state.user, state.session ? "session" : "user", state.session)),
+        actor: clone(actor(state)),
         osIdentity: needsIdentity ? osIdentity(state) : null };
     }
 
@@ -184,7 +194,7 @@ function attachIssuesService(ctx) {
       var liveIdentity = needsIdentity ? osIdentity(fresh) : null;
       if (fresh.project !== before.project || fresh.session !== before.session || (fresh.user.id || null) !== before.userId ||
           fresh.status.path !== before.path || !governing || governing.projectKnowledgeId !== before.knowledgeId ||
-          (fresh.status.changeSetId || null) !== before.changeSetId || fresh.worktreeOnly !== before.worktreeOnly ||
+          (fresh.status.changeSetId || null) !== before.changeSetId || fresh.worktreeOnly !== before.worktreeOnly || JSON.stringify(issueContext(fresh.status)) !== JSON.stringify(before.recordContext) ||
           JSON.stringify(liveIdentity) !== JSON.stringify(before.osIdentity)) throw new Error("Issue authorization changed during the operation.");
       return fresh;
     }
@@ -200,7 +210,7 @@ function attachIssuesService(ctx) {
     var github = require('./issues-github').attachIssueGithub({
       locks: githubLocks, assessments: githubAssessments, run: context.runGithub, analyze: source.analyzeGithub || context.analyzeGithub,
       begin: function () {
-        if (isSession) throw new Error('GitHub filing requires an explicit action in the Issues panel.');
+        if (isSession || canonicalClay) throw new Error('GitHub filing requires an explicit action in the Issues panel.');
         return operation(current(), true);
       },
       read: function (before, ref) {
@@ -217,6 +227,7 @@ function attachIssuesService(ctx) {
     return {
       searchGithubIssue: github.search, linkGithubIssue: github.link, createGithubIssue: github.create,
       linkWorkSession: function (args, session) {
+        if (canonicalClay) throw new Error("Use reviewed project assignment or follow-up for Driver execution.");
         var state = current();
         var manager = state.project.getSessionManager();
         if (!args || !Number.isInteger(args.expectedRevision)) throw new Error("expectedRevision is required.");
@@ -232,9 +243,10 @@ function attachIssuesService(ctx) {
         if (links.some(function (link) { return link.sessionId === session.sessionOriginId; })) return entry;
         var link = { sessionId: session.sessionOriginId, role: "driver", issueRevision: args.expectedRevision };
         if (args.requestId !== undefined) link.requestId = schema.text(args.requestId, "work request id", 200, true);
-        return target.update(args.ref, { linkedWorkSessions: links.concat([link]), status: "in_progress" }, args.expectedRevision, author(state.user, "user", null));
+        return target.update(args.ref, { linkedWorkSessions: links.concat([link]), status: "in_progress" }, args.expectedRevision, canonicalClay ? actor(state) : author(state.user, "user", null));
       },
       resolveWorkSession: function (args) {
+        if (canonicalClay) throw new Error("Work sessions require the existing project Driver workflow.");
         var state = current();
         var entry = visibleIssue(openStore(state.status), args.ref, state);
         if (!(entry.linkedWorkSessions || []).some(function (link) { return link.sessionId === args.sessionOriginId; })) throw new Error("Work session unavailable.");
@@ -255,9 +267,9 @@ function attachIssuesService(ctx) {
       readIssueTombstone: function (args) { var state = current(); return scopedIssue(openStore(state.status), args && args.ref, state); },
       issueHistory: function (args) { var state = current(); var store = openStore(state.status); var history = store.history(args && args.ref); if (state.worktreeOnly) { var historical = scopedIssue(store, args && args.ref, state); if (!historical.context || historical.context.changeSetId !== state.status.changeSetId) throw new Error("Issue not found."); } return history; },
       readIssueRevision: function (args) { var state = current(); var store = openStore(state.status); visibleIssue(store, args && args.ref, state); return store.readRevision(args.ref, args.revision); },
-      commentIssue: function (args) { var state = current(); var target = openStore(state.status); visibleIssue(target, args && args.ref, state); return target.comment(args.ref, args.body, author(state.user, "user", null)); },
+      commentIssue: function (args) { var state = current(); var target = openStore(state.status); expected(visibleIssue(target, args && args.ref, state), args); return target.comment(args.ref, args.body, canonicalClay ? actor(state) : author(state.user, "user", null)); },
       listIssueFeedback: function (args) {
-        if (!isSession) throw new Error("Only the Project Driver can review issue comments.");
+        if (!isSession && !canonicalClay) throw new Error("Only the Project Driver can review issue comments.");
         var state = current(); var target = openStore(state.status); var out = []; var feedbackLimit = args && args.limit === undefined ? 200 : Number(args.limit);
         if (!Number.isInteger(feedbackLimit) || feedbackLimit < 1 || feedbackLimit > 200) throw new Error("Feedback limit must be between 1 and 200.");
         var position = { issueCursor: null, issueIndex: 0, commentOffset: 0 };
@@ -297,31 +309,32 @@ function attachIssuesService(ctx) {
         return { feedback: out, total: out.length, nextCursor: nextCursor, truncated: !!nextCursor };
       },
       reviewIssueComment: function (args) {
-        if (!isSession) throw new Error("Only the Project Driver can review issue comments.");
+        if (!isSession && !canonicalClay) throw new Error("Only the Project Driver can review issue comments.");
         var state = current(); var target = openStore(state.status); var entry = visibleIssue(target, args && args.ref, state);
+        expected(entry, args);
         if (args.action === "incorporate") {
           if (!Number.isInteger(args.expectedRevision)) throw new Error("expectedRevision is required to incorporate a comment.");
           var data = cleanPublic(args, { ref: true, expectedRevision: true, commentId: true, action: true, response: true, commitSha: true }, true);
           if (data.status === "resolved") throw new Error("Use update_issue with verified commit evidence before resolving this Issue.");
-          return target.incorporate(entry.ref, args.commentId, data, args.expectedRevision, args.response, author(state.user, "session", state.session));
+          return target.incorporate(entry.ref, args.commentId, data, args.expectedRevision, args.response, actor(state));
         }
-        return target.review(entry.ref, args.commentId, args.action, args.response, author(state.user, "session", state.session));
+        return target.review(entry.ref, args.commentId, args.action, args.response, actor(state));
       },
       removeIssue: function (args) {
         var state = current();
         if (!state.principal.isProjectOwner) throw new Error("Only the project owner can delete Issues.");
         var target = openStore(state.status); var entry = visibleIssue(target, args && args.ref, state);
         if (!Number.isInteger(args && args.expectedRevision) || entry.revision !== args.expectedRevision) throw new Error("Issue revision conflict.");
-        return target.remove(entry.ref, author(state.user, "user", null), args.expectedRevision);
+        return target.remove(entry.ref, canonicalClay ? actor(state) : author(state.user, "user", null), args.expectedRevision);
       },
       createIssue: function (args) {
-        if (!isSession) throw new Error("People cannot create issues directly. Ask the Project Driver to create one.");
+        if (!isSession && !canonicalClay) throw new Error("People cannot create issues directly. Ask the Project Driver to create one.");
         var data = cleanPublic(args, { commitSha: true }, true);
         var status = data.status === undefined ? "open" : data.status;
         if (schema.STATUSES.indexOf(status) === -1) throw new Error("Invalid status.");
         var state = current();
         if (status !== "resolved") return Promise.resolve(openStore(state.status).create(data,
-          author(state.user, state.session ? "session" : "user", state.session), issueContext(state.status)));
+          actor(state), issueContext(state.status)));
         if (typeof data.resolutionSummary !== "string" || !data.resolutionSummary.trim()) throw new Error("resolutionSummary is required when resolving an issue.");
         var before = operation(state, true);
         return evidence(before, args.commitSha).then(function (proof) {
@@ -340,7 +353,7 @@ function attachIssuesService(ctx) {
         var existing = visibleIssue(target, ref, state);
         if (existing.revision !== expectedRevision) throw new Error("Issue revision conflict.");
         if (data.status !== "resolved") return Promise.resolve(target.update(ref, data, expectedRevision,
-          author(state.user, state.session ? "session" : "user", state.session)));
+          actor(state)));
         if (typeof data.resolutionSummary !== "string" || !data.resolutionSummary.trim()) throw new Error("resolutionSummary is required when resolving an issue.");
         var before = operation(state, true);
         return evidence(before, args.commitSha).then(function (proof) {
@@ -354,6 +367,7 @@ function attachIssuesService(ctx) {
   }
 
   return { bindUser: function (source) { return bind(source, false); },
+    bindCanonicalClay: function (source) { return bind(source, false, true); },
     bindProjectSession: function (source) { return bind(source, true); },
     issueScopeIdForKnowledgeId: issuesStore.issueScopeIdForKnowledgeId };
 }

package/lib/kiro-defaults.js

@@ -1,22 +1 @@
-// Kiro-specific default values. Single source of truth — do not duplicate
-// elsewhere. Consumed by the server-side vendor plumbing and sent to clients
-// via the config state so the UI renders the right controls.
-
-var KIRO_DEFAULTS = {
-  // Kiro CLI 2.18.1 exposes the next-generation agent as the v3 engine. Its
-  // general-purpose mode id is "vibe" (displayed as "Default").
-  engine: "v3",
-  mode: "vibe",
-};
-
-function getKiroConfig(sm) {
-  return {
-    engine: (sm && sm.kiroEngine) || KIRO_DEFAULTS.engine,
-    mode: (sm && sm.kiroMode) || KIRO_DEFAULTS.mode,
-  };
-}
-
-module.exports = {
-  KIRO_DEFAULTS: KIRO_DEFAULTS,
-  getKiroConfig: getKiroConfig,
-};
+module.exports = require("./yoke/options/kiro-defaults");

package/lib/knowledge-db-import.js

@@ -38,9 +38,10 @@ function attachKnowledgeDbImport(ctx) {
   }
   function importRecords(args) {
     // Snapshot caller-owned JSON before any asynchronous operation.
-    var batch = ctx.clone(input.batch(args)); args = ctx.clone(args);
+    var revalidate = args.revalidate; var batch = ctx.clone(input.batch(args)); args = ctx.clone(args); args.revalidate = revalidate;
     var operationId = ctx.mutationId(args.operationId); var fingerprint = ctx.fingerprint("import", args);
     return ctx.serialize(args.databaseId, function () { return ctx.load(args.databaseId).then(async function (current) {
+      ctx.guard(args, current);
       var duplicate = ctx.receipt(current, operationId, fingerprint);
       if (duplicate) return Object.assign({}, duplicate, { projectionPending: current.projectionPending === true, projectionError: current.projectionError || null });
       if (current.archivedAt) throw ctx.error("Knowledge database is archived.", "ARCHIVED", current.revision);
@@ -60,10 +61,10 @@ function attachKnowledgeDbImport(ctx) {
       // payload still conflicts. Preserve record values, archives and database revision.
       if (!added.length) {
         ctx.remember(next, operationId, fingerprint, result);
-        await ctx.replace(current, next);
+        await ctx.replace(current, next, args);
         return Object.assign(result, { projectionPending: current.projectionPending === true, projectionError: current.projectionError || null });
       }
-      var databases = await ctx.all(); var at = Date.now(); var who = ctx.actor(args.actor);
+      var databases = await ctx.all(); ctx.guard(args, current); var at = Date.now(); var who = ctx.actor(args.actor);
       added.forEach(function (item) {
         next.records.push({ id: item.mapping.recordId, revision: 1, values: {}, archivedAt: null, createdAt: at, updatedAt: at, createdBy: who, updatedBy: who });
         next.recordHistory[item.mapping.recordId] = [];
@@ -78,7 +79,7 @@ function attachKnowledgeDbImport(ctx) {
       next.revision++; next.updatedAt = at; next.updatedBy = who; next.projectionPending = true; next.projectionError = null;
       result.databaseRevision = next.revision;
       ctx.remember(next, operationId, fingerprint, result);
-      await ctx.replace(current, next);
+      await ctx.replace(current, next, args);
       return ctx.finish(next, result, who);
     }); });
   }

package/lib/knowledge-db-service.js

@@ -30,7 +30,7 @@ function canonical(value) {
   if (!value || typeof value !== "object") return value;
   var out = {}; Object.keys(value).sort().forEach(function (key) { out[key] = canonical(value[key]); }); return out;
 }
-function fingerprint(label, args) { var envelope = Object.assign({}, args); delete envelope.actor; delete envelope.operationId; return crypto.createHash("sha256").update(label + ":" + JSON.stringify(canonical(envelope))).digest("hex"); }
+function fingerprint(label, args) { var envelope = Object.assign({}, args); delete envelope.actor; delete envelope.operationId; delete envelope.revalidate; return crypto.createHash("sha256").update(label + ":" + JSON.stringify(canonical(envelope))).digest("hex"); }
 function ensureRevision(value, current, label) {
   if (!Number.isInteger(value) || value < 1) throw error("A valid " + label + " revision is required.", "STALE", current);
   if (value !== current) throw error("This " + label + " changed since it was opened.", "STALE", current);
@@ -114,7 +114,8 @@ function createKnowledgeDbService(options) {
   function all() { return storage.list(); }
   function listCached(args) { var items = storage.getCached(); return { databases: items.filter(function (item) { return args && args.archived === true ? !!item.archivedAt : !item.archivedAt; }).sort(function (a, b) { return b.updatedAt - a.updatedAt || (a._id === b._id ? 0 : a._id < b._id ? -1 : 1); }).map(function (item) { return publicDatabase(item, false); }) }; }
   function assertAggregate(next) { if (Buffer.byteLength(JSON.stringify(next), "utf8") > aggregateLimit) throw error("Knowledge database exceeds the " + aggregateLimit + " byte aggregate storage limit (records, history, mappings and live receipts).", "LIMIT"); }
-  function replace(current, next) { assertAggregate(next); return storage.replaceIfRevision(current._id, current.revision, next).then(function (replaced) { if (typeof replaced !== "boolean") throw storageModule.invalid("replaceIfRevision must resolve to a boolean."); if (!replaced) throw error("This database changed during the operation.", "STALE", current.revision); return next; }); }
+  function guard(args, current, phase) { if (args && typeof args.revalidate === 'function') args.revalidate(current ? publicDatabase(current, false) : null, phase); }
+  function replace(current, next, control) { assertAggregate(next); guard(control, current, 'saving'); return storage.replaceIfRevision(current._id, current.revision, next).then(function (replaced) { if (typeof replaced !== "boolean") throw storageModule.invalid("replaceIfRevision must resolve to a boolean."); if (!replaced) throw Object.assign(error("This database changed during the operation.", "STALE", current.revision), { persisted: false }); guard(control, null, "saved"); return next; }); }
   function projectionContent(value) { return JSON.stringify({ schemaVersion: 1, namespace: "knowledge-database-summary", databaseId: value._id, name: value.name, archived: !!value.archivedAt, revision: value.revision, fields: value.schema.filter(function (field) { return !field.archived; }).map(function (field) { return { id: field.id, name: field.name, type: field.type }; }), views: (value.views || []).filter(function (view) { return !view.archived; }).map(function (view) { return { id: view.id, name: view.name, type: "table" }; }), recordCount: value.records.filter(function (record) { return !record.archivedAt; }).length }); }
   function project(value, actorValue) {
     if (typeof settings.projectSummary !== "function") return Promise.resolve({ pending: false });
@@ -125,18 +126,20 @@ function createKnowledgeDbService(options) {
   function finish(value, result, actorValue) { return project(value, actorValue).then(function (projection) { return Object.assign({}, result, { projectionPending: projection.pending, projectionError: projection.error || null }); }); }
   function mutate(databaseId, args, label, fn) {
     var operationId = mutationId(args.operationId); var operationFingerprint = fingerprint(label, args); return serialize(databaseId, function () { return load(databaseId).then(function (current) {
+      guard(args, current);
       var duplicate = receipt(current, operationId, operationFingerprint); if (duplicate) return Object.assign({}, duplicate, { projectionPending: current.projectionPending === true, projectionError: current.projectionError || null });
       if (current.archivedAt && label !== "database") throw error("Knowledge database is archived.", "ARCHIVED", current.revision);
-      var next = clone(current); var result = fn(next, current); next.projectionPending = true; next.projectionError = null; remember(next, operationId, operationFingerprint, result); return replace(current, next).then(function () { return finish(next, result, actor(args.actor)); });
+      var next = clone(current); var result = fn(next, current); next.projectionPending = true; next.projectionError = null; remember(next, operationId, operationFingerprint, result); return replace(current, next, args).then(function () { return finish(next, result, actor(args.actor)); });
     }); });
   }
   function create(args) {
     var input = args || {}; var operationId = mutationId(input.operationId); var operationFingerprint = fingerprint("create", input); return serialize("create:" + operationId, function () { return all().then(function (items) {
+      guard(input);
       var duplicate; var duplicateDatabase; items.some(function (item) { duplicate = receipt(item, operationId, operationFingerprint); if (duplicate) duplicateDatabase = item; return !!duplicate; }); if (duplicate) return Object.assign({}, duplicate, { projectionPending: duplicateDatabase.projectionPending === true, projectionError: duplicateDatabase.projectionError || null });
       var at = now(); var who = actor(input.actor); var titleId = newId("fld"); var schema = input.schema ? validation.normalizeSchema(input.schema) : validation.normalizeSchema([{ id: titleId, name: "Name", type: "title", required: true }]);
       var viewId = newId("view"); var item = { _id: newId("db"), name: validation.text(input.name, "Database name", 120, false), revision: 1, archivedAt: null, schema: schema,
         views: [{ id: viewId, name: "Table", type: "table", columns: schema.filter(function (field) { return !field.archived; }).map(function (field) { return field.id; }), filters: [], sorts: [], archived: false }], records: [], recordHistory: {}, databaseHistory: [], receipts: [], createdAt: at, updatedAt: at, createdBy: who, updatedBy: who, projectionPending: true, projectionError: null };
-      var result = { database: publicDatabase(item, false) }; remember(item, operationId, operationFingerprint, result); assertAggregate(item); return storage.insert(item).then(function () { return finish(item, result, who); });
+      var result = { database: publicDatabase(item, false) }; remember(item, operationId, operationFingerprint, result); assertAggregate(item); guard(input, null, "saving"); return storage.insert(item).then(function () { guard(input, null, "saved"); return finish(item, result, who); });
     }); });
   }
   function list(args) { return all().then(function (items) { return { databases: items.filter(function (item) { return args && args.archived === true ? !!item.archivedAt : !item.archivedAt; }).sort(function (a, b) { return b.updatedAt - a.updatedAt || (a._id === b._id ? 0 : a._id < b._id ? -1 : 1); }).map(function (item) { return publicDatabase(item, false); }) }; }); }
@@ -155,8 +158,8 @@ function createKnowledgeDbService(options) {
   function archiveRecord(args) { return mutate(args.databaseId, args, "record", function (next) { var index = next.records.findIndex(function (record) { return record.id === validation.id(args.recordId, "record id"); }); if (index === -1) throw error("Knowledge database record not found.", "NOT_FOUND"); var before = next.records[index]; ensureRevision(args.expectedRevision, before.revision, "record"); next.recordHistory[before.id] = (next.recordHistory[before.id] || []).concat([{ revision: before.revision, at: now(), actor: actor(args.actor), action: args.recover === true ? "recover" : "archive", values: before.values, archivedAt: before.archivedAt }]).slice(-MAX_HISTORY); var record = clone(before); record.archivedAt = args.recover === true ? null : now(); record.revision++; record.updatedAt = now(); record.updatedBy = actor(args.actor); next.records[index] = record; next.revision++; next.updatedAt = record.updatedAt; next.updatedBy = record.updatedBy; return { databaseRevision: next.revision, record: publicRecord(record) }; }); }
   function readRecord(args) { return all().then(function (databases) { var item = databases.filter(function (entry) { return entry._id === validation.id(args.databaseId, "database id"); })[0]; if (!item) throw error("Knowledge database not found.", "NOT_FOUND"); var record = item.records.filter(function (entry) { return entry.id === validation.id(args.recordId, "record id"); })[0]; if (!record) throw error("Knowledge database record not found.", "NOT_FOUND"); return { database: publicDatabase(item, false), record: publicRecord(record, referenceStates(item, record, databases, settings)), title: titleValue(item, record), history: clone(item.recordHistory[record.id] || []) }; }); }
   function query(args) { return all().then(function (databases) { var item = databases.filter(function (entry) { return entry._id === validation.id(args.databaseId, "database id"); })[0]; if (!item) throw error("Knowledge database not found.", "NOT_FOUND"); if (item.archivedAt) throw error("Knowledge database is archived.", "ARCHIVED", item.revision); return queryRecords(item, args, databases, settings); }); }
-  function retryProjection(args) { return serialize(args.databaseId, function () { return load(args.databaseId).then(function (item) { return finish(item, { database: publicDatabase(item, false) }, actor(args.actor)); }); }); }
-  var importer = imports.attachKnowledgeDbImport({ clone: clone, error: error, actor: actor, newId: newId, mutationId: mutationId, fingerprint: fingerprint, ensureRevision: ensureRevision, receipt: receipt, remember: remember, serialize: serialize, load: load, all: all, referenceContext: referenceContext, replace: replace, finish: finish });
+  function retryProjection(args) { return serialize(args.databaseId, function () { return load(args.databaseId).then(function (item) { guard(args, item, "saving"); return finish(item, { database: publicDatabase(item, false) }, actor(args.actor)).then(function (result) { guard(args, null, "saved"); return result; }); }); }); }
+  var importer = imports.attachKnowledgeDbImport({ clone: clone, error: error, actor: actor, newId: newId, mutationId: mutationId, fingerprint: fingerprint, ensureRevision: ensureRevision, receipt: receipt, remember: remember, serialize: serialize, load: load, all: all, referenceContext: referenceContext, replace: replace, guard: guard, finish: finish });
   return { readStorageStatus: function () { return typeof storage.diagnostics === "function" ? storage.diagnostics() : Promise.resolve(null); }, importRecords: importer.importRecords, readImportProgress: importer.readImportProgress, hasStore: function () { return storage.hasStore(); }, isReady: function () { return storage.isReady(); }, initialize: function () { return Promise.resolve(storage.initialize()).then(function () {}); }, listCached: listCached, create: create, list: list, read: read, rename: rename, archive: archive, recover: function (args) { return archive(Object.assign({}, args, { recover: true })); }, updateSchema: updateSchema, saveView: saveView, createRecord: createRecord, updateRecord: updateRecord, archiveRecord: archiveRecord, recoverRecord: function (args) { return archiveRecord(Object.assign({}, args, { recover: true })); }, readRecord: readRecord, query: query, retryProjection: retryProjection };
 }
 

package/lib/knowledge-document-index.js

@@ -18,7 +18,8 @@ function createKnowledgeDocumentIndex(options) {
       if (file.size > options.maxDocumentBytes) { errors.push({ name: file.name, code: "TOO_LARGE", error: "Document exceeds the safe read limit." }); continue; }
       if (known && token && known.token === token) {
         if (bytes + known.bytes > MAX_INDEX_BYTES) { errors.push({ name: file.name, code: "INDEX_LIMIT", error: "Workspace Knowledge exceeds the safe index limit." }); continue; }
-        next[key] = known; documents.push(known.document); bytes += known.bytes; continue;
+        var fresh = Object.assign({}, known, { document: Object.assign({}, known.document, file) });
+        next[key] = fresh; documents.push(fresh.document); bytes += known.bytes; continue;
       }
       try { content = options.read(file); } catch (error) { errors.push({ name: file.name, code: error.code || "READ_FAILED", error: error.message }); continue; }
       var size = Buffer.byteLength(content, "utf8");

package/lib/knowledge-product-operations.js

@@ -0,0 +1,46 @@
+var validName = require('./knowledge-file-store').validName;
+// Narrow operations over the same document store used by the Knowledge workbench.
+function createKnowledgeProductOperations(ctx) {
+  function find(args, deleted) {
+    var item = args.documentId ? ctx.files.list().concat(deleted ? ctx.files.deleted() : []).find(function (entry) { return entry.id === args.documentId; }) : null;
+    if (args.documentId && !item) throw Object.assign(new Error('Knowledge document not found.'), { code: 'ENOENT' });
+    var name = args.name || item && item.name;
+    if (!name || item && args.name && args.name !== item.name) throw new Error('Choose one exact Knowledge document.');
+    if (item && item.deleted) return item;
+    var current = ctx.files.read(name);
+    if (current.itemType !== 'text') throw new Error('Legacy JSONL sources are read-only.');
+    return current;
+  }
+  function read(args) { var item = find(args); return { documentId: item.id, name: item.name, revision: item.revision, content: item.content }; }
+  function saved(item, who) { return Object.assign({ documentId: item.id, name: item.name, revision: item.revision, persisted: true }, ctx.mirror(who, [item.name])); }
+  function snapshot(op) {
+    if (op.action === 'retry_document_sync' && op.names.some(function (name) { return !validName(name); })) throw new Error('Invalid Knowledge source name.');
+    if (op.action === 'create_document') return ctx.files.list().filter(function (item) { return item.name === op.name; });
+    if (op.action === 'retry_document_sync') return ctx.files.list().filter(function (item) { return op.names.indexOf(item.name) >= 0; });
+    var item = find(op, op.action === 'restore_document');
+    var result = { documentId: item.id, name: item.name, revision: item.revision, deleted: !!item.deleted };
+    if (op.action === 'restore_document') result.version = ctx.files.readHistory(item.id, op.version);
+    if (op.action === 'rename_document') result.documents = ctx.files.list();
+    return result;
+  }
+  function mutate(op, who) {
+    if (op.action === 'create_document') return saved(ctx.files.save(op.name, op.content, null), who);
+    if (op.action === 'retry_document_sync') return Object.assign({ persisted: true }, ctx.mirror(who, op.names));
+    var item = find(op, op.action === 'restore_document');
+    if (op.action === 'update_document') return saved(ctx.files.save(item.name, op.content, op.expectedRevision), who);
+    if (op.action === 'rename_document') return ctx.rename({ from: item.name, name: op.newName, documentId: item.id, expectedRevision: op.expectedRevision }, who);
+    if (op.action === 'delete_document') { ctx.files.remove(item.name, op.expectedRevision); return Object.assign({ documentId: item.id, name: item.name, persisted: true, deleted: true }, ctx.mirror(who, [item.name])); }
+    if (op.action === 'restore_document') return saved(ctx.files.restore(item.id, op.version, item.name, item.deleted ? null : op.expectedRevision), who);
+    throw new Error('Unsupported Knowledge document operation.');
+  }
+  function query(op) {
+    if (op.action === 'list_documents') return { documents: op.deleted ? ctx.files.deleted() : ctx.files.list() };
+    if (op.action === 'read_document') return read(op);
+    var item = find(op, true);
+    if (op.action === 'document_history') return { documentId: item.id, name: item.name, versions: ctx.files.history(item.id) };
+    if (op.action === 'read_document_version') return Object.assign({ documentId: item.id, name: item.name }, ctx.files.readHistory(item.id, op.version));
+    throw new Error('Unsupported Knowledge document query.');
+  }
+  return { query: query, snapshot: snapshot, mutate: mutate };
+}
+module.exports = { createKnowledgeProductOperations: createKnowledgeProductOperations };

package/lib/mate-creation-mcp-server.js

@@ -13,6 +13,7 @@ function schema() {
     communicationStyle: z.string().describe("JSON array of communication preferences"),
     autonomy: z.string().describe("A concise description of autonomy, boundaries, and escalation behavior"),
     identityMarkdown: z.string().describe("The complete first-person Mate identity in Markdown"),
+    scheduleIntent: z.string().optional().describe("Optional JSON schedule intent to bind only after the Mate is created"),
   };
 }
 
@@ -39,6 +40,7 @@ function getToolDefs(onPropose) {
           communicationStyle: parseArray(args.communicationStyle, "communicationStyle"),
           autonomy: args.autonomy,
           identityMarkdown: args.identityMarkdown,
+          scheduleIntent: args.scheduleIntent || null,
         };
       } catch (error) {
         return Promise.resolve({ content: [{ type: "text", text: "Error: " + error.message }], isError: true });

package/lib/mate-knowledge-canonical-access.js

@@ -0,0 +1,10 @@
+var personal = require('./mcp-session-access');
+var provenance = require('./session-provenance');
+function assertCanonicalKnowledgeQuery(source, project, multiUser, generation, findUser) {
+  var session = source.session, manager = project && project.getSessionManager();
+  if (!session || !manager || manager.sessions.get(session.localId) !== session || Number(session._sdkQueryGeneration || 0) !== generation) throw new Error('This canonical Knowledge query is stale.');
+  if (session.destroying || session.hidden || session.taskStopRequested || session.abortController && session.abortController.signal.aborted || session.spawn || provenance.isWorker(session) || session.homeDebatePlanning || session.debateSetupMode || session._mentionInProgress || session.mateCreationMode || session.sessionVisibility === 'shared' || session._mcpForeignInput || session.delegated || session._delegatedBy || session._pairDelegation) throw new Error('Canonical Knowledge requires a live private owner-authored query.');
+  if (multiUser && (!source.projectOwnerId || session.ownerId !== source.projectOwnerId || !personal.canUsePersonalConnections(session, manager.sessions) || findUser && !findUser(source.projectOwnerId))) throw new Error('Canonical Knowledge owner access changed.');
+  if (!multiUser && (session.ownerId || (session.history || []).some(function (entry) { return entry.type === 'user_message' && entry.from && entry.from !== 'default'; }))) throw new Error('Foreign input cannot authorize canonical Knowledge.');
+}
+module.exports = { assertCanonicalKnowledgeQuery: assertCanonicalKnowledgeQuery };

package/lib/mate-knowledge-service.js

@@ -387,7 +387,7 @@ function attachMateKnowledgeService(ctx) {
     }
     if (typeof resolveMate !== "function") return null;
     var mate = resolveMate(source.projectOwnerId || null, source.mateId);
-    if (!mate || mate.id !== source.mateId) return null;
+    if (!mate || mate.lifecycleDeletion || mate.id !== source.mateId) return null;
     if (isMultiUser()) {
       if (!source.projectOwnerId) return null;
       if (mate.createdBy !== source.projectOwnerId) return null;
@@ -398,7 +398,7 @@ function attachMateKnowledgeService(ctx) {
 
     var def = mate.builtinKey ? builtinMates.getBuiltinByKey(mate.builtinKey) : null;
     var isClay = !!(mate.builtinKey === "clay" && def && def.hostAgent === true);
-    return { own: own, isClay: isClay, ownerId: source.projectOwnerId || null,
+    return { project: project, own: own, isClay: isClay, ownerId: source.projectOwnerId || null,
       databaseService: typeof project.getKnowledgeDbService === "function" ? project.getKnowledgeDbService() : null,
       actor: { type: "user", userId: source.session && source.session.ownerId || source.projectOwnerId || null, displayName: null } };
   }
@@ -410,12 +410,14 @@ function attachMateKnowledgeService(ctx) {
   // to work through a handler that was created while it was still live.
   function bind(source) {
     var initial = resolve(source);
+    var generation = Number(source && source.session && source.session._sdkQueryGeneration || 0);
     if (!initial) return null;
 
     function revalidate() {
       var current = resolve(source);
+      if (initial.isClay) require("./mate-knowledge-canonical-access").assertCanonicalKnowledgeQuery(source, getProjects().get(source.projectSlug), isMultiUser(), generation, context.findUser);
       if (!current) throw new Error("This Knowledge binding is no longer valid for the current session.");
-      if (current.isClay !== initial.isClay || current.own.scopeId !== initial.own.scopeId || current.databaseService !== initial.databaseService) {
+      if (current.project !== initial.project || current.isClay !== initial.isClay || current.own.scopeId !== initial.own.scopeId || current.databaseService !== initial.databaseService) {
         throw new Error("This Knowledge binding is no longer valid for the current session.");
       }
       return current;
@@ -446,7 +448,8 @@ function attachMateKnowledgeService(ctx) {
       for (var i = 0; i < listed.length; i++) {
         var entry = listed[i];
         if (!entry || !entry.id || !entry.dir) continue;
-        if (isMultiUser() && ownerId && entry.createdBy && entry.createdBy !== ownerId) continue;
+        var registered = resolveMate(ownerId, entry.id);
+        if (!registered || registered.lifecycleDeletion || isMultiUser() && registered.createdBy !== ownerId) continue;
         var scope = scopeForMate(entry.dir, entry.id, entry.name || null);
         if (!scope) continue;
         out.push(scope);

package/lib/mate-lifecycle-service.js

@@ -0,0 +1,94 @@
+var crypto = require('crypto');
+function attachMateLifecycleService(ctx) {
+  var busy = new Set();
+  function owner(userId) {
+    if (ctx.users.isMultiUser() && (!userId || !ctx.users.findUserById(userId))) throw new Error('Mate owner is unavailable.');
+    return ctx.mates.buildMateCtx(ctx.users.isMultiUser() ? userId : null);
+  }
+  function read(userId, id) {
+    var mate = ctx.mates.getMate(owner(userId), id);
+    if (!mate || ctx.users.isMultiUser() && mate.createdBy !== userId) throw new Error('Mate is unavailable or belongs to another owner.');
+    return mate;
+  }
+  function validateReceipt(userId, id, allowMissing) {
+    var mate = ctx.mates.getMate(owner(userId), id);
+    if (!mate && allowMissing) return;
+    if (!mate || ctx.users.isMultiUser() && mate.createdBy !== userId) throw new Error('Mate receipt access changed.');
+  }
+  function list(userId) {
+    return ctx.mates.getAllMates(owner(userId)).filter(function (mate) { return !ctx.users.isMultiUser() || mate.createdBy === userId; });
+  }
+  function broadcast(userId, message, ws) {
+    var seen = new Set();
+    function send(socket) {
+      if (!socket || seen.has(socket) || socket.readyState !== 1) return;
+      if (ctx.users.isMultiUser() && (!socket._clayUser || socket._clayUser.id !== userId)) return;
+      seen.add(socket); socket.send(JSON.stringify(message));
+    }
+    send(ws);
+    ctx.projects.forEach(function (project) { project.forEachClient(send); });
+  }
+  function update(userId, id, updates, ws, requestId) {
+    var mate = read(userId, id);
+    if (Object.prototype.hasOwnProperty.call(updates, 'lifecycleDeletion')) throw new Error('Mate deletion state is server-managed.');
+    if (busy.has(id) || mate.lifecycleDeletion) throw new Error('Mate deletion is pending.');
+    var updated = ctx.mates.updateMate(owner(userId), id, updates);
+    if (!updated || updated.error) throw new Error(updated && updated.error || 'Mate not found');
+    try {
+      broadcast(userId, { type: 'mate_updated', mate: updated, requestId: requestId }, ws);
+      if (ctx.refresh) ctx.refresh(owner(userId));
+    } catch (error) { error.productControlResult = { persisted: true, retrySafe: false }; throw error; }
+    return updated;
+  }
+  function idle(project) {
+    if (!project) return;
+    if (project.inspectMateLifecycleRuntime && project.inspectMateLifecycleRuntime().some(function (t) { return !t.exited; })) throw new Error('Close the Mate terminals before deletion.');
+    project.getSessionManager().sessions.forEach(function (session) {
+      if (session.isProcessing || session._queryStarting || session.queryInstance || session.worker || session.terminalId || session.runtimeTerminalId || Object.keys(session._mentionSessions || {}).length) throw new Error('Wait for this Mate runtime to become idle before deletion.');
+    });
+  }
+  async function closeRuntime(slug, validate) {
+    var timer;
+    try {
+      return await Promise.race([Promise.resolve().then(function () { if (validate) validate(true); return ctx.removeProject(slug, true); }), new Promise(function (resolve, reject) {
+        timer = setTimeout(function () { reject(new Error('Mate runtime cleanup timed out; deletion remains pending.')); }, 10000);
+      })]);
+    } finally { clearTimeout(timer); }
+  }
+  async function remove(userId, id, validate, ws) {
+    var mate = read(userId, id), slug = 'mate-' + id, project = ctx.projects.get(slug);
+    if (mate.primary || mate.builtinKey === 'clay') throw new Error('Canonical Clay and primary Mates cannot be deleted.');
+    if (busy.has(id)) throw new Error('Another Mate lifecycle operation is applying.');
+    idle(project);
+    if (validate) validate();
+    busy.add(id);
+    var persisted = false, runtimeClosed = false;
+    try {
+      // Retain an owner-visible tombstone until every required cleanup is acknowledged.
+      if (!mate.lifecycleDeletion) mate = ctx.mates.updateMate(owner(userId), id, { lifecycleDeletion: { id: crypto.randomUUID(), runtimeRequired: !!project, runtimeClosed: !project } });
+      if (!mate || mate.error) throw new Error('Could not persist the pending Mate deletion.');
+      persisted = true;
+      if (mate.builtinKey) ctx.users.addDeletedBuiltinKey(userId, mate.builtinKey);
+      if (!project && mate.lifecycleDeletion.runtimeRequired && !mate.lifecycleDeletion.runtimeClosed) throw new Error('Runtime cleanup proof is unavailable; retain the pending deletion for operator recovery.');
+      if (project && await closeRuntime(slug, validate) !== true) throw new Error('Mate runtime cleanup was not acknowledged.');
+      runtimeClosed = true;
+      mate = ctx.mates.updateMate(owner(userId), id, { lifecycleDeletion: Object.assign({}, mate.lifecycleDeletion, { runtimeClosed: true }) });
+      if (!mate || mate.error) throw new Error('Runtime closure proof could not be saved.');
+      if (validate) validate(true);
+      var current = read(userId, id);
+      if (!current.lifecycleDeletion || current.lifecycleDeletion.id !== mate.lifecycleDeletion.id) throw new Error('Mate deletion identity changed.');
+      var result = ctx.mates.deleteMate(owner(userId), id, { strictCleanup: true });
+      if (!result || !result.ok) throw new Error(result && result.error || 'Mate deletion was not persisted.');
+      var definitions = require('./builtin-mates');
+      var available = ctx.mates.getMissingBuiltinKeys(owner(userId)).map(function (key) { var def = definitions.getBuiltinByKey(key); return def && { key: def.key, displayName: def.displayName, bio: def.bio, avatarCustom: def.avatarCustom || '', avatarStyle: def.avatarStyle || 'imprint', avatarColor: def.avatarColor || '' }; }).filter(Boolean);
+      broadcast(userId, { type: 'mate_deleted', mateId: id, availableBuiltins: available }, ws);
+      if (ctx.refresh) ctx.refresh(owner(userId));
+      return { persisted: true, runtimeClosed: true, directoryRemoved: true };
+    } catch (error) {
+      error.productControlResult = { persisted: persisted, runtimeClosed: runtimeClosed, deletionPending: !!ctx.mates.getMate(owner(userId), id), retrySafe: false };
+      throw error;
+    } finally { busy.delete(id); }
+  }
+  return { read: read, validateReceipt: validateReceipt, list: list, update: update, remove: remove };
+}
+module.exports = { attachMateLifecycleService: attachMateLifecycleService };

package/lib/mate-message-delivery.js

@@ -0,0 +1,43 @@
+// Shared Home/Mate delivery. Canonical callers supply an exact live guard and
+// persist delegated provenance before any provider input is admitted.
+async function deliver(ctx, session, text, options) {
+  options = options || {};
+  var guarded = typeof options.revalidate === 'function';
+  function current() {
+    if (ctx.sm.sessions.get(session.localId) !== session) throw new Error('The conversation was deleted or replaced.');
+    if (guarded) {
+      options.revalidate();
+      if (session.taskStopRequested || session._pendingMessageDrainPaused || session._responseRecoveryStopPending || session.abortController && session.abortController.signal.aborted) throw new Error('The conversation is stopped; explicit owner resumption is required.');
+    }
+    return true;
+  }
+  if (guarded) current.exactProductDelivery = true;
+  current();
+  var event = options.event || { type: 'user_message', text: text };
+  if (guarded) {
+    if (ctx.sm.saveSessionFile(session) !== true) throw new Error('The conversation could not be saved; no provider delivery was attempted.');
+    if (ctx.sm.sendAndRecordDurably(session, event) !== true) throw new Error('The delegated message could not be saved; no provider delivery was attempted.');
+    session._mcpForeignInput = true;
+  } else ctx.sm.sendAndRecord(session, event);
+  var attempted = false;
+  try {
+    current();
+    var active = !!session.isProcessing;
+    session.isProcessing = true;
+    if (!active) session.sentToolResults = {};
+    if (options.onRecorded) options.onRecorded(session);
+    var queryText = options.queryText || text;
+    attempted = true;
+    if (session.queryInstance || session.worker && session.messageQueue === 'worker' || active) {
+      if (ctx.sdk.pushMessage(session, queryText, null) === true) return { status: 'queued', persisted: true, delivery: 'accepted', completion: 'pending' };
+      if (active) return { status: 'failed', persisted: true, delivery: 'rejected', retrySafe: false, error: 'The active provider did not accept the message. Inspect before another request.' };
+    }
+    var accepted = await ctx.sdk.startQuery(session, queryText, null, ctx.linuxUser || null, guarded ? current : undefined);
+    return { status: accepted === true ? 'started' : 'failed', persisted: true, delivery: accepted === true ? 'accepted' : 'not_confirmed', completion: 'pending', retrySafe: false };
+  } catch (error) {
+    if (!attempted) session.isProcessing = false;
+    error.productControlResult = { persisted: true, delivery: attempted ? 'unknown' : 'not_attempted', retrySafe: false };
+    throw error;
+  }
+}
+module.exports = { deliver: deliver };

package/lib/mate-ready-creation.js

@@ -4,6 +4,7 @@ var resolveMateIdentityFile = require('./mate-identity-file').resolveMateIdentit
 
 var fs = require("fs");
 var path = require("path");
+var scheduleInput = require("./mate-schedule-input");
 
 function cleanLine(value, maxLength, field) {
   if (typeof value !== "string") throw new Error(field + " is required.");
@@ -27,6 +28,11 @@ function normalize(definition) {
   var identity = typeof definition.identityMarkdown === "string" ? definition.identityMarkdown.replace(/\u0000/g, "").trim() : "";
   if (identity.length < 200) throw new Error("The Mate identity is incomplete.");
   if (identity.length > 30000) throw new Error("The Mate identity is too long.");
+  var scheduleIntent = definition.scheduleIntent || null;
+  if (scheduleIntent) {
+    var scheduleChecked = scheduleInput.normalize(scheduleIntent);
+    scheduleIntent = { message: scheduleChecked.message, scheduleRule: scheduleChecked.rule };
+  }
   return {
     name: cleanLine(definition.name, 80, "Mate name"),
     bio: cleanLine(definition.bio, 280, "Mate bio"),
@@ -37,6 +43,7 @@ function normalize(definition) {
     identityMarkdown: identity,
     vendor: cleanLine(definition.vendor || "claude", 40, "Vendor"),
     model: cleanLine(definition.model, 240, "Mate model"),
+    scheduleIntent: scheduleIntent,
   };
 }
 
@@ -54,6 +61,7 @@ function createReadyMate(mates, mateCtx, definition) {
       vendor: ready.vendor,
       model: ready.model,
       autonomy: ready.autonomy,
+      scheduleIntent: ready.scheduleIntent,
     });
     var mateDir = mates.getMateDir(mateCtx, mate.id);
     var identityPath = resolveMateIdentityFile(mateDir);
@@ -80,7 +88,7 @@ function createReadyMate(mates, mateCtx, definition) {
       vendor: ready.vendor,
       model: ready.model,
       profile: Object.assign({}, mate.profile || {}, { displayName: ready.name, bio: ready.bio }),
-      seedData: Object.assign({}, mate.seedData || {}, { relationship: ready.relationship, activity: ready.activities, communicationStyle: ready.communicationStyle, autonomy: ready.autonomy }),
+      seedData: Object.assign({}, mate.seedData || {}, { relationship: ready.relationship, activity: ready.activities, communicationStyle: ready.communicationStyle, autonomy: ready.autonomy, scheduleIntent: ready.scheduleIntent }),
     });
     mates.backupIdentity(mateDir, ready.identityMarkdown);
     mates.logIdentityChange(mateDir, "clay_interview", ready.identityMarkdown, "");