clay-server 4.0.0-beta.12 → 4.0.0-beta.14

package/lib/project-log-feedback-delivery.js

@@ -0,0 +1,76 @@
+// Deliver new Project Log comments to the exact live session responsible for
+// the canonical entry. Comments remain durable in the ledger when that session
+// is gone; this module never guesses another session or creates one.
+
+function attachProjectLogFeedbackDelivery(ctx) {
+  var sm = ctx.sm;
+  var getSdk = ctx.getSdk;
+  var onProcessingChanged = ctx.onProcessingChanged || function () {};
+  var getLinuxUserForSession = ctx.getLinuxUserForSession || function () { return null; };
+
+  function findAuthorSession(entry) {
+    var author = entry && entry.updatedBy;
+    if (!author || author.type !== "session" || !author.sessionKey) return null;
+    var match = null;
+    sm.sessions.forEach(function (session) {
+      if (match || !session || session.destroying || session.hidden) return;
+      if (session.cliSessionId !== author.sessionKey && "local:" + session.localId !== author.sessionKey) return;
+      if ((session.ownerId || null) !== (author.userId || null)) return;
+      if (sm.sessions.get(session.localId) !== session) return;
+      match = session;
+    });
+    return match;
+  }
+
+  function feedbackPrompt(entry) {
+    return "[Project Log feedback]\n" +
+      "A user added a comment to " + entry.ref + ". Review the pending feedback now with list_log_feedback, " +
+      "then resolve this specific comment through review_log_comment. Apply supported corrections to the canonical " +
+      "entry; otherwise clarify or decline with a concise reason. Do not treat this internal notification as user " +
+      "chat or answer it only in the conversation.\n" +
+      "[End Project Log feedback]";
+  }
+
+  function deliver(entry) {
+    if (!entry || !entry.ref || !entry.pendingFeedbackCount) return false;
+    var session = findAuthorSession(entry);
+    var sdk = getSdk();
+    if (!session || !sdk) return false;
+    var text = feedbackPrompt(entry);
+    sm.sendAndRecord(session, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    session.lastActivity = Date.now();
+    if (!session.isProcessing) {
+      session.isProcessing = true;
+      session.sentToolResults = {};
+      onProcessingChanged();
+      sm.sendToSession(session, { type: "status", status: "processing" });
+    }
+    if (!sdk.pushMessage(session, text)) {
+      session._queryStartTs = Date.now();
+      Promise.resolve(sdk.startQuery(session, text, null, getLinuxUserForSession(session))).catch(function (error) {
+        session.isProcessing = false;
+        sm.sendAndRecord(session, {
+          type: "error",
+          text: "Could not deliver Project Log feedback: " + (error.message || String(error)),
+          _internal: true,
+        });
+        onProcessingChanged();
+      });
+    }
+    sm.broadcastSessionList();
+    return true;
+  }
+
+  return {
+    deliver: deliver,
+    findAuthorSession: findAuthorSession,
+  };
+}
+
+module.exports = { attachProjectLogFeedbackDelivery: attachProjectLogFeedbackDelivery };

package/lib/project-logs-mcp-server.js

@@ -21,21 +21,22 @@ var LOGS_CONTRACT =
   "Do not log conversation summaries, task narration, restatements of the request, completed-work announcements, speculation, or anything the repository and its history already record. " +
   "Every write is attributed and permanently revision-tracked, so keep entries short, concrete, and true.";
 
-// Learning moments are a durable project asset, so capturing them is a default
-// rather than an option. The point is to help the person's own model get
-// sharper, not to replace their thinking: a concept they can name is a concept
-// they can reuse without asking again.
+// User learning moments are a durable project asset, so capturing them is a
+// default rather than an option. This category is about a change in the user's
+// conceptual model, never knowledge the Driver acquired while doing the work.
 var LEARNING_CONTRACT =
-  "Capture durable learning moments as Project Logs, normally under the category `learning`. " +
-  "There are two kinds. First, the person asks a conceptual question directly and the answer is durable and relevant to this project. " +
-  "Second, and easier to miss: the person describes something in their own approximate words and you identify the precise term, model, or mechanism behind it. " +
+  "Capture durable user learning moments as Project Logs, normally under the category `learning`. " +
+  "A learning entry is exclusively about the user's learning: the user must have engaged with a concept they did not previously know, or expressed an approximate mental model that you made more precise. It is never a record of something you, the Driver, learned or discovered while inspecting the project. " +
+  "There are two kinds. First, the user asks a conceptual question directly and the answer is durable and relevant to this project. " +
+  "Second, and easier to miss: the user describes something in their own approximate words and you identify the precise term, model, or mechanism behind it. " +
   "If someone says the background is transparent and blurry and you name that as backdrop blur, implemented with the CSS backdrop-filter property, that is a learning moment and it should not evaporate when the conversation scrolls away. " +
-  "Record four things: the person's original wording or mental model, the precise concept it corresponds to, why and how it applies in this project, and any boundary or common misconception worth knowing. " +
+  "Record four things: the user's original wording or mental model, the precise concept it corresponds to, why and how it applies in this project, and any boundary or common misconception worth knowing. " +
   "Write the title and summary so they teach at a glance: someone reading only the ledger row should come away knowing the concept. " +
   "When it comes to learning, always capture once these criteria are met; treat it as the default rather than a judgement call. " +
   "Never fabricate a learning moment, and never claim someone learned something they did not actually engage with. " +
   "Attribute respectfully and factually: write that a concept was clarified in discussion. Never grade, rank, or characterise the person's knowledge. " +
-  "Do not log routine command syntax, trivial confirmations, facts the person clearly already knows, or every explanation you happen to give. Capture when a conceptual model becomes measurably more precise. " +
+  "Do not classify engineering lessons, repository discoveries, investigation outcomes, defect causes, implementation insights, decisions, or facts you learned during the work as learning; use an appropriate category such as `investigation`, `defect`, `decision`, or `reference`. " +
+  "Do not log routine command syntax, trivial confirmations, facts the user clearly already knows, or every explanation you happen to give. Capture when the user's conceptual model becomes measurably more precise. " +
   "When new learning refines or supersedes an existing learning entry, revise that entry instead of adding a near-duplicate.";
 
 // Sticky Notes and Project Logs are different layers, and the failure mode is
@@ -71,9 +72,10 @@ var CATEGORY_DESCRIPTION = "Record category: a short lowercase hyphen-separated
   "Letters and digits in any script are accepted, so a project may keep its vocabulary in the language it works in. " +
   "This project's own vocabulary, not a fixed list. Call list_logs or search_logs first and reuse an established category when one fits; " +
   "coin a new concise one only when this project needs a durable distinction it does not yet have. " +
-  "Common starting points are " + logsSchema.SEED_CATEGORIES.join(", ") + ". A category is dry metadata, never a persona or an identifier.";
+  "Common starting points are " + logsSchema.SEED_CATEGORIES.join(", ") + ". A category is dry metadata, never a persona or an identifier. " +
+  "Use `learning` only for a user learning moment described by the learning contract, never for knowledge or lessons acquired by the Driver.";
 var PRIORITY_DESCRIPTION = "How much this outranks routine work: " + logsSchema.PRIORITIES.join(", ") + ". Defaults to normal. Priority is independent of category, so an urgent decision is both.";
-var SUMMARY_DESCRIPTION = "One or two sentences explaining what was decided or done and why. This is what a reader sees in the ledger, so it must stand alone. For a learning entry, name the concept plainly enough that the row itself teaches it.";
+var SUMMARY_DESCRIPTION = "One or two sentences explaining what was decided or done and why. This is what a reader sees in the ledger, so it must stand alone. For a learning entry, identify the concept the user engaged with plainly enough that the row itself teaches it.";
 var REF_DESCRIPTION = "Opaque log reference returned by list_logs, search_logs, or create_log.";
 
 function textResult(value) {
@@ -152,7 +154,7 @@ function projectTools(bound) {
         priority: { type: "string", enum: logsSchema.PRIORITIES, description: PRIORITY_DESCRIPTION },
         title: { type: "string", description: "Short factual title, plain text, written like a good commit subject." },
         summary: { type: "string", description: SUMMARY_DESCRIPTION },
-        body: { type: "string", description: "The durable facts, context, and outcome in Markdown. No narration of your own activity. For a learning entry, cover the original wording or mental model, the precise concept, how it applies here, and any boundary or misconception." },
+        body: { type: "string", description: "The durable facts, context, and outcome in Markdown. No narration of your own activity. For a learning entry, cover the user's original wording or mental model, the precise concept, how it applies here, and any boundary or misconception." },
         tags: { type: "string", description: "Optional JSON array of short tag strings." },
       }, ["kind", "title", "summary"]),
       handler: handler(bound, "createLog"),

package/lib/project-logs.js

@@ -88,6 +88,7 @@ function attachProjectLogs(ctx) {
   var sendTo = ctx.sendTo;
   var getClients = ctx.getClients || function () { return []; };
   var getProjectOwnerId = ctx.getProjectOwnerId || function () { return null; };
+  var onFeedback = ctx.onFeedback || function () {};
 
   // Every socket in this project's client set passed the project access check
   // at WebSocket upgrade, so a broadcast here is already scoped to authorized
@@ -204,6 +205,9 @@ function attachProjectLogs(ctx) {
       if (msg.type === "project_log_comment") {
         var commented = bound.commentLog({ ref: msg.ref, body: msg.body });
         sendTo(ws, { type: "project_log_commented", requestId: requestId, entry: commented });
+        try { onFeedback(commented); } catch (deliveryError) {
+          console.error("[project-logs] Failed to deliver comment:", deliveryError.message || deliveryError);
+        }
         return true;
       }
     } catch (e) {

package/lib/project-pair-lifecycle.js

@@ -1,13 +1,13 @@
 // Autonomous Split Worker lifecycle: bounded status, atomic replacement, and
 // the per-generation evaluation ledger.
 //
-// A qualified Driver manages its visible Worker without asking the user: it
+// A Driver manages its visible Worker without asking the user: it
 // decides reuse against replacement from exact server-derived accounting, and
 // it replaces in one operation rather than a close/create dance. Nothing here
 // posts a proposal or waits for an approval card.
 //
 // Everything is bound to the exact live pair. The Driver is re-resolved from
-// the split store on every call, its eligibility is re-checked every time, and
+// the split store on every call, its structural capability is re-checked every time, and
 // ownership must match on both sessions. No active-tab or global-session
 // fallback exists in this module.
 //
@@ -130,6 +130,7 @@ function activityStatus(session) {
 function attachPairLifecycle(ctx) {
   var sm = ctx.sm;
   var store = ctx.splitStore;
+  var turnControl = ctx.turnControl;
 
   // Per-Driver ledger of the Worker generations it has run, newest last.
   // Lives on the live Driver session object: it informs the Driver's next
@@ -186,7 +187,7 @@ function attachPairLifecycle(ctx) {
     return record;
   }
 
-  // The exact pair, with the Driver's eligibility re-checked on every call.
+  // The exact pair, with the Driver's structural capability re-checked on every call.
   function resolveDriverPair(caller) {
     if (!caller) throw new Error("pair lifecycle tools require a session-bound tool server");
     // Exact live object identity, before anything is read off the caller. A
@@ -205,7 +206,7 @@ function attachPairLifecycle(ctx) {
     var worker = sm.sessions.get(group.pair.workerId);
     if (!worker) throw new Error("split partner session was not found");
     if ((caller.ownerId || null) !== (worker.ownerId || null)) throw new Error("split partner access denied");
-    return { group: group, worker: worker, tier: verdict.tier };
+    return { group: group, worker: worker };
   }
 
   function replaceBlockedReason(worker) {
@@ -219,7 +220,7 @@ function attachPairLifecycle(ctx) {
   function partnerStatus(caller) {
     var resolved = resolveDriverPair(caller);
     var worker = resolved.worker;
-    var blocked = replaceBlockedReason(worker);
+    var blocked = turnControl.blockedReason(caller) || replaceBlockedReason(worker);
     var ledger = ledgerFor(caller).map(function (record) {
       return {
         generation: record.generation,
@@ -242,9 +243,9 @@ function attachPairLifecycle(ctx) {
       activity: activityStatus(worker),
       context: contextStatus(worker),
       continuity: continuityStatus(worker),
+      orchestration: turnControl.status(caller),
       replaceSafe: !blocked,
       replaceBlockedReason: blocked,
-      driverTier: resolved.tier ? resolved.tier.name : null,
       generations: ledger,
     };
   }
@@ -258,6 +259,7 @@ function attachPairLifecycle(ctx) {
     var resolved = resolveDriverPair(caller);
     var group = resolved.group;
     var oldWorker = resolved.worker;
+    turnControl.assertWorkerAction(caller);
 
     // Validate the replacement while the old pair is still fully intact. An
     // uninstalled vendor, an unavailable model or an unsupported effort must
@@ -275,6 +277,9 @@ function attachPairLifecycle(ctx) {
         "; call again with interrupt set to true to stop it first");
     }
 
+    if (args.evaluation) validateEvaluation(args.evaluation);
+    var creationTicket = turnControl.reserveCreation(caller, "replace");
+
     if (blocked) {
       oldWorker.taskStopRequested = true;
       if (oldWorker.abortController) {
@@ -290,15 +295,12 @@ function attachPairLifecycle(ctx) {
       ctx.cancelWorkerPermissions(oldWorker, "The Driver replaced this Split Worker.");
     }
 
-    // The outgoing generation is closed only after the replacement exists, so a
-    // rollback leaves its ledger entry open and its evaluation untouched. The
-    // evaluation shape is still checked here, before anything is destroyed, so
-    // a malformed assessment cannot dissolve the pair and then be rejected.
-    if (args.evaluation) validateEvaluation(args.evaluation);
-
     var ws = { _clayUser: caller.ownerId ? { id: caller.ownerId } : null };
     var dissolved = store.dissolve(ws, { id: group.id });
-    if (!dissolved.ok) throw new Error(dissolved.error || "could not dissolve the existing pair");
+    if (!dissolved.ok) {
+      turnControl.releaseCreation(creationTicket);
+      throw new Error(dissolved.error || "could not dissolve the existing pair");
+    }
 
     // History is preserved: the old Worker session stays in the project.
     //
@@ -334,6 +336,7 @@ function attachPairLifecycle(ctx) {
       var interruptNote = blocked
         ? " Its interrupted turn cannot be resumed, because stopping it was explicitly requested."
         : "";
+      turnControl.releaseCreation(creationTicket);
       throw new Error("could not create the replacement Split Worker: " + (e.message || String(e)) +
         ". " + restoreNote + interruptNote);
     }

package/lib/project-session-pair.js

@@ -2,12 +2,11 @@ var pairMcp = require("./session-pair-mcp-server");
 var pairPrompts = require("./session-pair-prompts");
 var { attachPairFactory } = require("./session-pair-factory");
 var { attachPairLifecycle } = require("./project-pair-lifecycle");
+var { attachPairTurnControl } = require("./session-pair-turn-control");
 var driverEligibility = require("./session-driver-eligibility");
 var { attachWorkerPermission } = require("./project-worker-permission");
 var { attachWorkerProposal } = require("./project-worker-proposal");
-
 var MAX_RESPONSE_CHARS = 30000;
-
 function toolResult(value) {
   return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
 }
@@ -65,13 +64,10 @@ function attachSessionPair(ctx) {
   var workerProposal;
   var workerPermission;
   var lifecycle;
-
+  var turnControl = attachPairTurnControl({ sm: sm, splitStore: store });
   function groupAndPartner(caller) {
     if (!caller) throw new Error("partner tools require a session-bound tool server");
-    // Exact live object identity. MCP tool handlers are captured per query and
-    // outlive the session they were bound to, so a stale session object — or a
-    // different object reusing the same localId — must not be able to drive a
-    // pair through a handler someone still holds a reference to.
+    // Captured handlers must remain bound to the exact live Session object.
     if (sm.sessions.get(caller.localId) !== caller) {
       throw new Error("this session is no longer live; the partner tools are bound to an exact session");
     }
@@ -106,11 +102,10 @@ function attachSessionPair(ctx) {
     broadcastDelegation(group, caller, partner, false);
   }
 
-  // Deliver an internal message to the Driver and make sure it is running so
-  // the message is actually consumed. Shared by the delegated-result push-back
-  // and by Split Worker permission routing, so both use one resume path.
+  // Shared resume path for delegated results and Worker permission routing.
   function resumeDriverWithMessage(caller, text, meta) {
     if (!caller || caller.destroying) return false;
+    if (turnControl.blockedReason(caller)) return false;
     var record = {
       type: "user_message",
       text: text,
@@ -165,9 +160,7 @@ function attachSessionPair(ctx) {
     });
   }
 
-  // A Driver blocked inside a waiting send_to_partner cannot answer a tool
-  // call. Asking the wait to detach lets its turn continue; the delegated
-  // result then arrives through the existing detached push-back path.
+  // Give a waiting Driver its turn back so it can answer Worker permissions.
   function requestDetach(worker) {
     var token = worker && worker._pairDelegation;
     if (!token || token.detached || token.detachRequested) return false;
@@ -216,9 +209,7 @@ function attachSessionPair(ctx) {
           });
           return;
         }
-        // Either the deadline passed, or something needs the Driver's turn
-        // back before then (a Split Worker permission request). Both detach
-        // the same way, so the completed result still returns automatically.
+        // Timeouts and permission requests both detach into the push-back path.
         if (Date.now() >= deadline || token.detachRequested) {
           clearInterval(timer);
           token.detached = true;
@@ -245,9 +236,12 @@ function attachSessionPair(ctx) {
       if (caller && caller._delegatedBy) throw new Error("delegated turns cannot delegate to another session");
       var message = typeof args.message === "string" ? args.message.trim() : "";
       if (!message) throw new Error("message is required");
+      turnControl.assertWorkerAction(caller);
       var created = null;
       if (caller && !store.groupForMember(caller.localId)) {
-        created = createWorkerForDriver(caller, args);
+        var creationTicket = turnControl.reserveCreation(caller, "create");
+        try { created = createWorkerForDriver(caller, args); }
+        catch (createError) { turnControl.releaseCreation(creationTicket); throw createError; }
       }
       var resolved = groupAndPartner(caller);
       if (created && created.worker) lifecycle.recordGenerationStart(caller, created.worker);
@@ -367,6 +361,13 @@ function attachSessionPair(ctx) {
     }
   }
 
+  function handleHumanStop(session) {
+    var roles = turnControl.markHumanStop(session);
+    if (!roles) return false;
+    workerPermission.cancelForSession(roles.worker, "The human stopped this Split Worker turn.");
+    return true;
+  }
+
   function getToolDefs(boundSession) {
     if (!boundSession) return pairMcp.getToolDefs({
       send: function () { return toolError(new Error("send_to_partner requires a session-bound tool server")); },
@@ -377,36 +378,32 @@ function attachSessionPair(ctx) {
       replace: function () { return toolError(new Error("replace_partner requires a session-bound tool server")); },
       evaluate: function () { return toolError(new Error("record_partner_evaluation requires a session-bound tool server")); },
     });
-    // Mount whenever we have a bound session: MCP servers are fixed for the
-    // lifetime of a query, and Claude queries live across turns, so gating on
-    // group membership HERE would permanently hide the tools from a session
-    // whose split is created mid-conversation (the ad-hoc flow). Handlers
-    // re-resolve the group on every call, so an ungrouped session gets a
-    // clear error, and a session that gains a partner later just works.
-    // The one structural exclusion: a session that is ALREADY a configured
-    // pair worker at query start never sees the tools.
+    // Mount for the query lifetime; handlers re-resolve live pair state.
     var group = store.groupForMember(boundSession.localId);
     if (group && group.pair && group.pair.driverId !== boundSession.localId) return [];
-    // A plain side-by-side split has no Driver role, so it keeps exactly the
-    // partner tools it always had. Every path that would make this session a
-    // Driver — an existing configured pair, or an unpaired session whose
-    // send_to_partner would create one — requires the hard tier invariant. A
-    // model below its family's threshold never receives the autonomous
-    // lifecycle tools and cannot create or direct a pair.
+    // Every project chat model may drive; the check only excludes non-chat surfaces.
     var adHocSplit = !!(group && !group.pair);
     if (!adHocSplit && !driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
     var lifecycleHandlers = lifecycle.toolHandlers(boundSession);
     var tools = pairMcp.getToolDefs({
-      send: function (args) { return sendToPartner(args, boundSession); },
+      send: function (args) {
+        return turnControl.runOperation(boundSession, "send", args && args.operationId, function () {
+          return sendToPartner(args || {}, boundSession);
+        });
+      },
       read: function (args) { return readPartner(args, boundSession); },
       interrupt: function (args) { return interruptPartner(args, boundSession); },
       close: function (args) { return closePartner(args, boundSession); },
       status: lifecycleHandlers.status,
-      replace: lifecycleHandlers.replace,
+      replace: function (args) {
+        return turnControl.runOperation(boundSession, "replace", args && args.operationId, function () {
+          return lifecycleHandlers.replace(args || {});
+        });
+      },
       evaluate: lifecycleHandlers.evaluate,
     }, { lifecycle: !adHocSplit });
     return tools
-      .concat(workerPermission.getToolDefs(boundSession))
+      .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: !group }))
       .concat(workerProposal.getToolDefs(boundSession));
   }
 
@@ -427,6 +424,7 @@ function attachSessionPair(ctx) {
     cancelWorkerPermissions: function (worker, reason) {
       return workerPermission.cancelForSession(worker, reason);
     },
+    turnControl: turnControl,
   });
 
   workerPermission = attachWorkerPermission({
@@ -483,7 +481,9 @@ function attachSessionPair(ctx) {
   }
 
   return {
+    beginHumanTurn: turnControl.beginHumanTurn,
     getToolDefs: getToolDefs,
+    handleHumanStop: handleHumanStop,
     handleMessage: handleMessage,
     handleTurnDone: handleTurnDone,
     getSystemPrompt: getSystemPrompt,

package/lib/project-sessions.js

@@ -1004,7 +1004,8 @@ function attachSessions(ctx) {
 
     if (msg.type === "stop") {
       var session = getSessionForWs(ws);
-      if (session && session.isProcessing) {
+      if (session && (session.isProcessing || session._queryStarting)) {
+        if (typeof ctx.onHumanPairStop === "function") ctx.onHumanPairStop(session);
         session.taskStopRequested = true;
         if (session.abortController) session.abortController.abort();
       }

package/lib/project-user-message.js

@@ -331,6 +331,7 @@ function attachUserMessage(ctx) {
       });
       return true;
     }
+    if (typeof ctx.beginHumanPairTurn === "function") ctx.beginHumanPairTurn(session);
     if (gitAttribution) gitAttribution.beginTurn(session);
 
     // Bind vendor to session on first message (if not already set)

package/lib/project-worker-permission.js

@@ -328,10 +328,11 @@ function attachWorkerPermission(ctx) {
   }
 
   // Exposed to the Driver only, and only while it really is a pair Driver.
-  function getToolDefs(boundSession) {
+  function getToolDefs(boundSession, options) {
     if (!boundSession || !store) return [];
     var group = store.groupForMember(boundSession.localId);
-    if (!group || !group.pair || group.pair.driverId !== boundSession.localId) return [];
+    var dormantDriver = !!(options && options.dormantDriver);
+    if (!dormantDriver && (!group || !group.pair || group.pair.driverId !== boundSession.localId)) return [];
     return [{
       name: "respond_to_worker_permission",
       description: "Approve or deny one tool-permission request raised by your paired Split Worker. " +

package/lib/project.js

@@ -51,6 +51,7 @@ var { attachSessionDocument } = require("./project-session-document");
 var { attachCapsuleCatalog } = require("./project-capsule-catalog");
 var { attachProjectWorkspaceQuery } = require("./project-workspace-query");
 var { attachProjectLogs } = require("./project-logs");
+var { attachProjectLogFeedbackDelivery } = require("./project-log-feedback-delivery");
 var { attachProjectMateKnowledge } = require("./project-mate-knowledge");
 var { attachSplitGroups } = require("./session-split-groups");
 var toolControlMcp = require("./tool-control-mcp-server");
@@ -670,6 +671,12 @@ function createProjectContext(opts) {
     isMate: isMate,
     mateId: mateId,
   });
+  var _logFeedbackDelivery = attachProjectLogFeedbackDelivery({
+    sm: sm,
+    getSdk: function () { return sdk; },
+    onProcessingChanged: onProcessingChanged,
+    getLinuxUserForSession: getLinuxUserForSession,
+  });
   var _projectLogs = attachProjectLogs({
     service: opts.projectLogsService || null,
     sm: sm,
@@ -679,6 +686,7 @@ function createProjectContext(opts) {
     mateId: mateId,
     sendTo: sendTo,
     getClients: function () { return clients; },
+    onFeedback: _logFeedbackDelivery.deliver,
   });
   var _mateKnowledge = attachProjectMateKnowledge({
     service: opts.mateKnowledgeService || null,
@@ -1599,6 +1607,7 @@ function createProjectContext(opts) {
     matesModule: matesModule,
     pushModule: pushModule,
     getSessionForWs: getSessionForWs,
+    onHumanPairStop: function (session) { return _sessionPair.handleHumanStop(session); },
     getLinuxUserForSession: getLinuxUserForSession,
     ensureProjectAccessForSession: ensureProjectAccessForSession,
     getOsUserInfoForWs: getOsUserInfoForWs,
@@ -1674,6 +1683,7 @@ function createProjectContext(opts) {
       if (isMate || !_sessionPair.workerPermission) return false;
       return _sessionPair.workerPermission.isDriverOperated(session);
     },
+    beginHumanPairTurn: function (session) { return _sessionPair.beginHumanTurn(session); },
     cwd: cwd,
     slug: slug,
     isMate: isMate,

package/lib/public/app.js

@@ -344,8 +344,6 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     projectLogsCommentStatusEl: null,
     projectLogsUnread: 0,
     projectLogsSeenRevisions: {},
-    projectLogsPreview: false,
-    projectLogsPinned: false,
     installedTools: [],
     homeToolRegistryLoaded: false,
     toolScanErrors: [],