@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/i18n/messages.en.js

@@ -117,6 +117,7 @@ const EN = {
     'model.subagent.ambiguous': "Subagent model {word} matches more than one model name that differ only in case — spell it exactly; the subagent will run on its parent's model.",
     'model.catalogDefault.refused.named': 'A task that names no model would be refused: the engine cannot resolve a default model from its model configuration (the settings default is {name}) · Set a default model the engine can run, or add or fix one',
     'model.catalogDefault.refused.select': 'A task that names no model would be refused: the engine cannot resolve a default model from its model configuration (the settings default is a selection) · Change the selection, or add or fix a model the engine can run',
+    'session.sync.pushRowBitsWriterSide': 'The session was pushed · At the destination it is a read-only mirror, so its title and pin stay with the side that writes it and were not changed there',
     'session.devices.laneAbsent': 'This backend has no remote-control lane',
     'session.devices.laneUnreported': "This backend doesn't report a remote-control lane",
     'session.devices.verbsOff': "This backend's device lane is on, but its device-management verbs are off — devices can't be listed or changed here",
@@ -124,12 +125,30 @@ const EN = {
     'session.devices.probeFailedTransport': "Couldn't reach the engine to check for a remote-control lane — try again",
     'session.devices.probeFailedRefused': 'The engine refused the device-list check — try again',
     'session.devices.probeFailedUnreadable': "The engine's device list couldn't be read — try again",
-    'session.engine.selfNotLocal': "This session runs on the engine this app started on this device, but it was started as a Cloud session. Nothing was changed — check how this session was opened.",
+    'session.engine.selfNotLocal': "This session runs on this device's local engine, but it was started as a Cloud session. Nothing was changed — check how this session was opened.",
     'session.engine.dispatch.notWired': "This session's engine isn't connected right now, so nothing was sent. Connect to that engine, then try again.",
     'session.engine.dispatch.scopeMismatch': "This session belongs to an engine in a different space from the one you're signed in to, so nothing was sent. Switch to that space, then try again.",
     'session.engine.dispatch.scopeUnproven': "Your current sign-in can't be confirmed to reach this session's engine, so nothing was sent. Sign in to that engine's space (or connect to the engine directly), then try again.",
     'session.engine.dispatch.unresolved': "This session's engine isn't known yet, so nothing was sent. Choose the engine for this session once, then try again.",
     'session.engine.dispatch.sessionAmbiguous': 'This session is registered on two engines at once, so nothing was sent. Stop here and resolve which engine it belongs to first.',
+    'session.mcpReconnect.notRunning': 'No run of this session is live on this engine right now (it may be waiting for an answer, have finished, or be running elsewhere), so {server} was not re-dialed; a run that starts or resumes dials its declared servers again.',
+    'session.mcpReconnect.unsupported': 'This engine does not support re-dialing an MCP server during a session; {server} was not re-dialed.',
+    'session.mcpReconnect.notFound': 'The engine did not find this session, so {server} was not re-dialed.',
+    'session.mcpReconnect.invalid': 'The re-dial request for {server} was not valid (the session id or the server name was unusable), so it was not re-dialed.',
+    'session.mcpReconnect.failed': 'Could not re-dial {server} on the engine: the request did not complete.',
+    'session.mcpReconnect.noSession': 'There is no engine session yet, so {server} was not re-dialed on the engine.',
+    'session.mcpReconnect.unavailable': 'Re-dialing {server} on the engine is not available here.',
+    'session.mcpReconnect.accepted.one': 'MCP server {server} was re-dialed: {toolCount} tool mounted for this run ({added} added, {removed} removed)',
+    'session.mcpReconnect.accepted.other': 'MCP server {server} was re-dialed: {toolCount} tools mounted for this run ({added} added, {removed} removed)',
+    'session.mcpReconnect.refused.untouched': 'MCP server {server} was NOT re-dialed; its connection and tools were left untouched{why}',
+    'session.mcpReconnect.refused.noTools': "MCP server {server} was NOT re-dialed; this run's tool list has no tools from it right now (the dial failed, or this run's tool settings let none of its tools through){why}",
+    'session.mcpReconnect.refused.listed.one': 'MCP server {server} was NOT re-dialed; the engine reports {toolCount} tool for it after this attempt{why}',
+    'session.mcpReconnect.refused.listed.other': 'MCP server {server} was NOT re-dialed; the engine reports {toolCount} tools for it after this attempt{why}',
+    'session.mcpReconnect.undeclared': 'This run declared no MCP servers, so there is nothing to re-dial ({server} is not part of this run){why}',
+    'session.mcpReconnect.unsettled': "The MCP re-dial did not settle within the time this request waits, so there is no result yet: the re-dial was not cancelled and may still be running. Check the server's state before re-dialing it again — a second request that arrives after the dial has settled closes the connection and dials once more.",
+    'session.mcpReconnect.reasonTail': ' — {reason}',
+    'session.mcpFailure.reauthorizeSuffix': ' (re-authorize)',
+    'session.mcpFailure.serverDownSuffix': ' (the server is down)',
     'config.cloudLogin.accessDenied': 'Sign-in was declined.',
     'config.cloudLogin.expiredToken': 'The sign-in code expired before it was approved — start again.',
     'config.cloudLogin.invalidGrant': 'The Cloud sign-in can no longer be renewed — sign in again.',
@@ -252,6 +271,7 @@ const EN = {
     'approval.settle.cause.streamDisconnected': 'the connection carrying this card dropped',
     'approval.settle.cause.undeliverable': 'it could not be delivered to any approval surface',
     'approval.resolution.engineUnavailable': 'The engine is temporarily unavailable — answer this once the engine is back.',
+    'approval.allowNote.notCarried': "This engine can't take a note on Yes — a note written here is not sent to the model.",
     'approval.decide.requiresBinding': 'This decision was sent without the binding that ties it to the exact action on the approval card, so the engine refused it · Nothing was decided and the approval is still pending · Fetch the pending approvals again and decide from the card as it is listed now; if the listed card itself carries no binding, {wayOut}',
     'approval.decide.unboundWayOut.armed': 'it cannot be decided here — cancel the run or let the approval expire',
     'approval.decide.unboundWayOut.none': 'it cannot be decided here — cancel the run (this approval has no expiry timer)',
@@ -261,11 +281,18 @@ const EN = {
     'approval.rowUnresumable.askNotSurfaced': 'the pending row (task {taskId}) cannot be continued by this engine, so it is not surfaced as a card that can be answered: {sentence}',
     'approval.park.stillParked': '{gate} gate could not be answered: {reason} — the run is still parked on this approval.',
     'approval.park.refusedNotResumable': '{gate} gate could not be answered: {reason} — this engine cannot resume this approval as things stand; cancel the run if it is still parked.',
+    'approval.park.resume.card': '{gate} gate could not be answered: {reason} — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.',
+    'approval.park.resume.speak': '{gate} gate could not be answered: {reason} — the run is still parked on this approval: send a message to reopen the card, then decide it there, or cancel the run.',
+    'approval.park.argsFromModelCall': "the pending approval record has no tool arguments that will run, so the arguments shown are the model's original call from the conversation — if they were changed after that call (for example by a hook), what runs differs from what is shown. Edits are not accepted on this card: the arguments shown are not the ones that will run",
+    'approval.park.questionsFromModelCall': "the pending approval record has no questions to present, so the questions shown are the model's original call from the conversation — if they were changed after that call (for example by a hook), the question the engine is actually asking may differ from what is shown",
     'approval.policyDeny.denyRule': 'Permission for this tool use was denied by a deny rule in the permission settings. {tail}',
     'approval.policyDeny.dontAsk': 'Permission for this tool use was denied: this session no longer asks for approval, so a call that would need approval is refused. {tail}',
     'approval.policyDeny.engineFloor': 'Permission for this tool use was denied by a safeguard on the engine side that permission settings cannot override. {tail}',
     'approval.policyDeny.tail': 'The action was NOT performed. Do not claim it succeeded, and do not retry it in this session — report the limitation to the user, or suggest an alternative.',
     'approval.decision.grantChanged': 'The engine refused this approval because the skill grant it was bound to has changed since the card was shown · Nothing was decided and the request is still waiting, but approving it again will be refused the same way · Deny this request so the model can activate the skill again',
+    'approval.decision.answerInvalid': 'The engine rejected the answer itself because it does not fit the question that was asked · Nothing was decided and the question is still waiting · Correct the answer and send it again',
+    'approval.editRefusal.line': 'That approval was NOT sent: this request does not expose its tool arguments here, so an edited approval cannot be applied. ' +
+        'The request is still waiting — approve or deny it as it is.',
     'approval.decision.settledElsewhereContrary.deniedFirst': 'This request was already answered elsewhere and denied, so your approval did not take effect.',
     'approval.decision.settledElsewhereContrary.approvedFirst': 'This request was already answered elsewhere and approved, so your denial did not take effect.',
     'approval.decision.unconfirmedAfterRetry': "It is not known whether your answer took effect: an earlier attempt to send it was not confirmed, and by the time it was sent again the request was no longer waiting · Check the task's current state before acting on it",
@@ -550,6 +577,9 @@ const EN = {
     'approval.mandate.wayOut.crossBoundaryTaint': "an allow that comes from configuration — a setting that allows everything, or a policy's own answer — is refused for this call, so what you approve or deny here is what settles it",
     'approval.mandate.unknownWord': 'the reason reported for this confirmation is not one this client recognises, so it shows no reason',
     'approval.card.payloadUnreadable': 'This client cannot read the format of this approval card, so only its basic facts are shown — decide from those, or deny it if you are not sure what it will do.',
+    'approval.card.payloadUnreadable.versionUnknown': 'This client does not recognise the format version of this approval request, so only its essential facts are shown — decide from those, or deny it if you are not sure what it will do.',
+    'approval.card.payloadUnreadable.fieldsMalformed': 'This approval request uses a format version this client knows, but some of its fields are malformed and could not be read, so only its essential facts are shown — decide from those, or deny it if you are not sure what it will do.',
+    'approval.card.payloadUnreadable.partUnknown': 'This client cannot read one part of this approval request, so only its essential facts are shown — decide from those, or deny it if you are not sure what it will do.',
     'approval.card.more.one': '1 more reason for this card is not shown.',
     'approval.card.more.other': '{count} more reasons for this card are not shown.',
     'approval.card.denialLimit.plain': 'auto-deny limit reached — auto mode denied enough calls on its own that the engine now wants a real human decision; {consecutive} consecutive / {total} total automatic denials so far; the limit that tripped: {limit}',
@@ -628,6 +658,8 @@ const EN = {
     'session.hostSettings.heldPrevious': 'A settings file could not be read cleanly just now (it may be in the middle of being saved), so the permission rules from the last clean read are still applied.',
     'session.hostSettings.styleMissing': 'The output style "{name}" selected in your settings could not be found or read, so it is not applied to this request.',
     'session.hostSettings.styleSafeMode': 'Safe mode is on, so the output style from your settings is not applied.',
+    'session.hostSettings.styleOversize': 'Your output style was not applied to this request: together with the built-in product context it is longer than the {limit}-character limit. Shorten the style to apply it.',
+    'session.hostSettings.styleUnreadable': 'Your output style could not be read as text, so it is not applied to this request.',
     'model.identity.lane.processEnv': 'the environment this client was started with',
     'model.identity.lane.settingsEnv': "this client's settings file",
     'model.identity.lane.modelCatalogFile': 'the local model catalog file',
@@ -653,6 +685,105 @@ const EN = {
     'notice.userInputUndrained.approvalFeedback.other': '{count} notes you wrote when approving a tool call never reached the model and will not be delivered. Send them again if you still need them.',
     'notice.askUnresolvable.remedy.approver': 'Way out: connect an approver who can answer requests like this one, or make the connected approver reachable, then try again',
     'notice.askUnresolvable.remedy.permissionMode': 'Another way out, if this deployment allows it: the {mode} permission mode lets requests like this one through without anyone answering them, and each request let through this way is marked on the tool call it applied to',
+    'notice.durableGate.lead': 'Durable approval is not available in this session — {mandate}, but {cause}, so approval requests cannot be saved to be answered later.',
+    'notice.durableGate.mandate.forceDurableGate': 'this account requires it',
+    'notice.durableGate.mandate.durableApproval': 'this task asked for it',
+    'notice.durableGate.mandate.other': 'it was required',
+    'notice.durableGate.cause.noDeploymentStore': 'no checkpoint store is set up on this deployment',
+    'notice.durableGate.cause.taskStoreDisabled': 'this task turned its checkpoint store off',
+    'notice.durableGate.cause.other': 'no checkpoint store is available for it',
+    'notice.durableGate.approver.live': 'Permission requests are answered live in this session instead.',
+    'notice.durableGate.approver.noneAttached': "No live approver is attached to this session, so permission requests follow the engine's configured posture instead.",
+    'notice.durableGate.approver.unreported': "Permission requests follow the engine's configured posture instead.",
+    'notice.durableGate.question.refused': 'Questions the assistant would ask you cannot be shown here, so they are refused.',
+    'notice.durableGate.exit.noDeploymentStore': 'To use durable approval, the deployment needs a checkpoint store.',
+    'notice.durableGate.exit.taskStoreDisabled': 'To use durable approval, run the task with its checkpoint store turned on.',
+    'notice.durableGate.exit.other': 'To use durable approval, a checkpoint store has to be available.',
+    'notice.durableGate.exitAlt.forceDurableGate': 'Or ask whoever runs the deployment to drop the requirement for this account.',
+    'notice.durableGate.exitAlt.durableApproval': 'Or run the task where a live approver is attached.',
+    'notice.memory.sessionPolluted': 'Memory for this session is marked externally exposed ({reason}). From here on, memory it writes may be held back for review instead of being saved to the long-term library; what each batch actually held back is announced separately.',
+    'notice.memory.harvestQuarantined.counts': 'Memory harvest held back entry files written or changed in this session instead of adding them to the long-term library — withheld {count}, moved aside for review {moved}, flagged for follow-up {escalated}; the last two counts can overlap.',
+    'notice.memory.harvestQuarantined.indexOnly': "Memory harvest rolled this session's changes to the memory index back to where they started; no entry files were withheld.",
+    'notice.memory.harvestQuarantined.indexAlso': 'The memory index was also rolled back.',
+    'notice.memory.delegationWaived.lead': "A delegation would have marked this session's memory as polluted, but it was not marked: this deployment does not mark on a delegation's static tool check alone, so that check was waived.",
+    'notice.memory.delegationWaived.agentType': 'Agent type: {agentType}.',
+    'notice.memory.delegationWaived.reason': 'What the check found: "{reason}".',
+    'notice.memory.delegationWaived.tail': 'Other pollution findings, and any memory capture opt-out on this session, are not affected.',
+    'notice.memory.captureOptedOut.flipVerb': 'Memory capture is off for this session from this point on — anything it produced before the switch was still subject to the usual capture.',
+    'notice.memory.captureOptedOut.standingRecord': 'Memory capture stays off for this session — a standing opt-out record from an earlier leg governs it, and a later leg cannot turn it back on.',
+    'notice.memory.captureOptedOut.delegationFloor': 'Memory capture is off for this delegated session — the opt-out of the session that started it is a floor a child cannot loosen (this session did not declare it).',
+    'notice.memory.captureOptedOut.forkOrigin': "Memory capture is off for this forked session — it continues an opted-out session, and that session's one-way opt-out governs the copy (this session did not declare it).",
+    'notice.memory.captureOptedOut.declaration': 'Memory capture is off for this session, as declared when it was submitted.',
+    'notice.memory.captureOptedOut.other': 'Memory capture is off for this session.',
+    'notice.memory.captureOptedOut.tail': 'Nothing it produces is committed to the long-term memory store. Entries committed before the opt-out stay in the library and stay retrievable; deleting them is a separate action, never a side effect of this switch. The switch is one-way: start a new session to capture again.',
+    'notice.memory.captureOptoutUnpersisted.lead': 'The memory capture opt-out for this session could not be durably recorded (the control-plane write failed).',
+    'notice.memory.captureOptoutUnpersisted.declaration': 'So the session was refused rather than run under a switch that would silently stop holding at the next resume: nothing ran and nothing was captured. Repair the control plane (or wire a capture record store), then start a new session.',
+    'notice.memory.captureOptoutUnpersisted.flipVerb': 'So only the request was rejected: this run keeps going and its memory capture is still on. Nothing was recorded, so an identical retry fails the same way; stop the run if this session must not be captured.',
+    'notice.memory.captureOptoutUnpersisted.other': "So it was not honored. This notice alone does not say whether anything stopped — read the run's own outcome for that. Nothing was recorded, so an identical retry fails the same way.",
+    'notice.peer.subject.message': 'An incoming cross-session message #{seq}',
+    'notice.peer.subject.messageFrom': 'An incoming cross-session message #{seq} from {from}',
+    'notice.peer.subject.notice': 'An incoming cross-session notice #{seq}',
+    'notice.peer.subject.noticeFrom': 'An incoming cross-session notice #{seq} from {from}',
+    'notice.peer.subject.held': 'Held cross-session message #{seq}',
+    'notice.peer.subject.heldFrom': 'Held cross-session message #{seq} from {from}',
+    'notice.peer.inbound.refused': "{subject} was refused by this session's policy and was never delivered.",
+    'notice.peer.inbound.admissionRefused': '{subject} was refused at admission.',
+    'notice.peer.inbound.held': '{subject} is held for the next round — it has not been delivered yet, and it has not been rejected.',
+    'notice.peer.inbound.noticeUnrouted': '{subject} had nowhere to be delivered.',
+    'notice.peer.inbound.noticeUserOnly': '{subject} was shown to you only — the model did not read it.',
+    'notice.peer.inbound.resupplyExhausted': "{subject} may never have been read by the model: context compaction dropped it from the model's context twice, and the sender was not told.",
+    'notice.peer.inbound.other': '{subject} was reported with a disposition this version does not recognize.',
+    'notice.peer.inbound.cause': 'Cause: {cause}.',
+    'notice.sessionBox.peer.another': 'another session',
+    'notice.sessionBox.peer.anotherStart': 'Another session',
+    'notice.sessionBox.inbox.one': '1 cross-session message waiting',
+    'notice.sessionBox.inbox.many': '{pending} cross-session messages waiting',
+    'notice.sessionBox.inbox.urgent': '({urgent} urgent)',
+    'notice.sessionBox.inbox.resupplied': '(resupplied {resupplied})',
+    'notice.sessionBox.delivery.delivered': 'Your message to {peer} was delivered.',
+    'notice.sessionBox.delivery.held': "Your message to {peer} is waiting for that session's approval.",
+    'notice.sessionBox.delivery.heldByPolicy': "Your message to {peer} is held by that session's own settings; nobody there is asked to approve it.",
+    'notice.sessionBox.delivery.denied': 'Your message to {peer} was declined by that session.',
+    'notice.sessionBox.delivery.refused': '{peer} is not accepting cross-session messages; your message was not delivered.',
+    'notice.sessionBox.delivery.expired': 'Your message to {peer} expired before it was approved.',
+    'notice.sessionBox.delivery.dropped': 'Your message to {peer} was dropped ({reason}).',
+    'notice.sessionBox.delivery.droppedPlain': 'Your message to {peer} was dropped.',
+    'notice.sessionBox.delivery.other': 'There is a delivery update for your message to {peer}.',
+    'notice.sessionBox.idle.finished': '{peer} finished its turn.',
+    'notice.sessionBox.idle.finishedDetail': '{peer} finished its turn: {detail}',
+    'notice.sessionBox.idle.exited': '{peer} has exited.',
+    'notice.sessionBox.idle.unavailable': '{peer} is unavailable.',
+    'notice.sessionBox.idle.expired': '{peer} did not answer before the wait ran out.',
+    'notice.sessionBox.idle.other': 'There is a status update from {peer}.',
+    'notice.peer.held.deliveredApproved': '{subject} was approved and delivered.',
+    'notice.peer.held.deliveredRejudged': '{subject} was re-judged and delivered, because the policy now accepts it.',
+    'notice.peer.held.droppedRejudged': '{subject} was approved, but the policy now refuses it, so it was dropped.',
+    'notice.peer.held.droppedInjectFailed': '{subject} was approved, but the injection lane refused it when it was released, so it was dropped.',
+    'notice.peer.held.evicted': '{subject} was expired to make room: the held queue is full ({heldCount} still held).',
+    'notice.peer.held.expiredDeadline': '{subject} expired at the review deadline and was not delivered.',
+    'notice.peer.held.expiredCancelled': '{subject} was cancelled and not delivered.',
+    'notice.peer.held.expiredShutdown': '{subject} was expired at shutdown and not delivered.',
+    'notice.peer.held.denied': '{subject} was denied and not delivered.',
+    'notice.peer.held.refused': '{subject} was refused by policy and not delivered.',
+    'notice.peer.held.retiredSuperseded': '{subject} left the held queue without a decision here: another consumer already settled it.',
+    'notice.peer.held.decidedElsewhere': '{subject} was decided by another consumer of the box first.',
+    'notice.peer.held.retiredOther': "{subject} left this session's held queue without a decision here.",
+    'notice.peer.held.other': "{subject} left this session's held queue (this version does not recognize the outcome).",
+    'notice.peer.idle.recorded': 'The session {from} asked to be told when this session is next idle; the request was recorded.',
+    'notice.peer.idle.refreshed': 'The session {from} asked again to be told when this session is next idle; its earlier request was refreshed.',
+    'notice.peer.idle.full': "The session {from} asked to be told when this session is next idle, but this session's subscription list is full, so the request was declined.",
+    'notice.peer.idle.refused': 'The session {from} asked to be told when this session is next idle, but this session refuses messages from other sessions, so the request was declined.',
+    'notice.peer.idle.other': 'The session {from} asked to be told when this session is next idle.',
+    'notice.peer.idle.waiting': 'Subscribers now waiting on this session: {live}.',
+    'notice.classifier.denialLimit.consecutive': "The run was stopped: the permission classifier blocked {count} tool calls in a row and hit its denial limit, and nobody judged the follow-up request for a person's decision.",
+    'notice.classifier.denialLimit.total': "The run was stopped: the permission classifier blocked {count} tool calls in this run and hit its denial limit, and nobody judged the follow-up request for a person's decision.",
+    'notice.classifier.denialLimit.other': "The run was stopped: the permission classifier hit its denial limit, and nobody judged the follow-up request for a person's decision.",
+    'notice.classifier.denialLimit.tool': 'Latest blocked action: {tool}.',
+    'notice.classifier.denialLimit.tail': 'Review the transcript, then change the step that keeps getting blocked or make an approver available, and run it again.',
+    'notice.task.lateApproval': 'Your approval for "{tool}" was not consumed: a run or turn interrupt released that request before your decision landed, so the tool did not run and nothing was settled by your answer. This is a timing fact, not an error; ask again if that step is still needed.',
+    'notice.task.haltUnconsumed': "Your stop request did not cut anything: the run was already ending for its own reason when it arrived, so nothing was stopped by it and the run's own ending stands.",
+    'notice.steering.parkedInputBlocked': "An instruction you sent while this run was paused was blocked when the run resumed: this deployment's input screen withheld it, so it never reached the model. Send it again if it still applies.",
+    'notice.model.capabilityDowngraded.image': 'The images in this conversation were not sent to {model}: its catalog entry declares that it does not take image input, so each image reaches it as a one-line placeholder. If it can read images, declare that in the model entry (input: ["text", "image"]); otherwise switch to a model that can.',
     'rules.refusal.sentence.one': 'permissions: 1 rule will not be enforced — {list}',
     'rules.refusal.sentence.other': 'permissions: {count} rules will not be enforced — {list}',
     'rules.refusal.item': '{rule} ({reason})',
@@ -735,6 +866,10 @@ const EN = {
     'session.steerRefusal.advice': '{happened} — {nextStep}',
     'session.steerRefusal.hostQueue.queued': 'it stays queued and will be submitted as-is when this turn ends',
     'session.steerRefusal.hostQueue.dropped': 'it was not kept; {nextStep}',
+    'session.interruptRefusal.nothingInFlight': 'The interrupt was not accepted: this run is waiting on a pending decision, so there is no turn in flight to cut · The run itself was not changed and is still waiting · To end it, stop the whole run; to give it a message, send one — it is delivered when the run resumes',
+    'session.interruptRefusal.notHeld': 'The interrupt was not accepted: this server has no live turn it can cut for this run — the run may be running on another server, or on a path that exposes no live turn · The run itself was not changed · To end it, stop the whole run',
+    'session.interruptRefusal.notRunning': 'The interrupt was not accepted: this run is not running any more — it has just finished, or it no longer takes an interrupt · Nothing was cut or changed · Check its current state before doing anything else',
+    'session.interruptRefusal.unrecognised': 'The interrupt was not accepted, for a reason this version cannot name · Do not assume the run has stopped or that any turn was cut · Check its current state; if this keeps happening, report the error code (if the engine gave one)',
     'session.permissionModeSwitch.applied': 'The running turn now uses the {mode} permission mode.',
     'session.permissionModeSwitch.folded': 'The running turn now uses the {mode} permission mode instead of the one you chose — {reason}.',
     'session.permissionModeSwitch.reason.entryFloor': 'this deployment does not allow a looser mode than its floor',
@@ -871,6 +1006,8 @@ const EN = {
     'notice.failure.headline.parked': 'The event stream ended while the run had not reached a terminal state — the run is likely parked waiting for a decision, not crashed. Check its status and decide anything pending; the turn did not complete here.',
     'notice.failure.headline.internal': 'This client hit an internal error — it is a bug in the client, not an engine outage, and the turn did not complete.',
     'notice.failure.headline.causeUnreadable': 'The reason for this failure could not be read (part of the error object was unreadable) — it is not known whether the engine received your message. Check the run’s status, or reattach to it, before sending it again.',
+    'notice.streamEnded.emptyLegs.headline': 'The event stream came back empty twice in a row and ended while the run had not reached a terminal state — the run is likely parked waiting for a decision, not crashed. Check its status and decide anything pending; the turn did not complete here.',
+    'notice.streamEnded.consecutiveFailures.headline': 'The event stream kept ending without progress and the client stopped re-opening it — it is not known whether the run is still going or is waiting for a decision. Check its status, or reattach to it, before sending again; the turn did not complete here.',
     'notice.failure.quota.fiveHour': 'Your 5-hour quota is used up',
     'notice.failure.quota.weekly': 'Your weekly quota is used up',
     'notice.failure.quota.budgetPersonal': 'Your personal budget is used up',
@@ -1017,6 +1154,24 @@ const EN = {
     'notice.wireRefusal.autonomyLane': 'The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting',
     'notice.wireRefusal.sessionArchiveStamped': "This session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written · Delete the session and push it again",
     'notice.wireRefusal.sessionArchiveStamped.fork': "This session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written · This conversation keeps running on its own history; to fork it, delete the session and push it again",
+    'notice.wireRefusal.envCredential': 'The engine did not accept this request: its settings.env carries credentials, and the engine does not take credentials from a request',
+    'notice.wireRefusal.envCredential.folded': 'This parked work cannot continue: the request saved for it carries credentials in settings.env, and the engine does not take credentials from a request; nothing was resumed',
+    'notice.wireRefusal.envCredential.names': 'Entries: {names}',
+    'notice.wireRefusal.envCredential.remedy': "Put the credentials in the engine's own process environment, then send the request again without those entries",
+    'notice.wireRefusal.sessionIdRetired': 'The engine did not accept this request: its session id belonged to a session that was deleted on this server, and work under that id now runs only for the session\'s earlier owner · Use a new session',
+    'notice.wireRefusal.sessionIdRetired.folded': 'This parked work cannot continue: its session id belonged to a session that was deleted on this server, and work under that id now runs only for the session\'s earlier owner; nothing was resumed and the card is still waiting',
+    'notice.wireRefusal.runConcurrencyCap.head': 'This deployment already has as many runs in flight as it allows, so the engine did not accept this request · Nothing is wrong with the request itself',
+    'notice.wireRefusal.runConcurrencyCap.unknownWait': 'Send it again once one of the runs in flight has finished',
+    'notice.wireRefusal.unreadMembers': 'The engine did not accept this request: it carries {part} that this server version cannot read as written, and running it would silently leave that part out',
+    'notice.wireRefusal.unreadMembers.folded': 'This parked work cannot continue: the request saved for it carries {part} that this server version cannot read as written, and continuing would silently leave that part out; nothing was resumed and the card is still waiting',
+    'notice.wireRefusal.unreadMembers.where': 'Where: {where}',
+    'notice.wireRefusal.unreadMembers.remedy': 'Send the request again with that part in the current form',
+    'notice.wireRefusal.unreadMembers.folded.remedy': 'Cancel the work if it is still suspended, then submit it again as a new request with that part in the current form',
+    'notice.wireRefusal.unreadMembers.part.settingsHooks': 'hook settings',
+    'notice.wireRefusal.unreadMembers.part.settingsEnv': 'environment variables',
+    'notice.wireRefusal.unreadMembers.part.settingsOther': 'a setting',
+    'notice.wireRefusal.unreadMembers.part.mcpTransport': "an MCP server's connection settings",
+    'notice.wireRefusal.unreadMembers.part.a2aHeaders': "an A2A peer's request headers",
     'notice.wireRefusal.unsupportedRule': 'The engine refused this request, so none of it took effect: a rule in it is a form the engine does not support — {detail} · Remove or rewrite that rule (to stop a tool altogether, write its name alone), then send it again',
     'notice.wireRefusal.unsupportedRule.other': 'The engine refused this request, so none of it took effect: {count} rules in it are forms the engine does not support — {detail} · Remove or rewrite those rules (to stop a tool altogether, write its name alone), then send it again',
     'notice.wireRefusal.unsupportedRule.stored': 'The engine refused to continue this work: the request stored for it has a rule in it that is a form the engine does not support — {detail} · It cannot continue as stored. Remove or rewrite that rule (to stop a tool altogether, write its name alone), cancel the work if it is still suspended, then submit it again as a new request',
@@ -1078,15 +1233,20 @@ const EN = {
     'session.subagent.delegatedPrompt.absence.forbidden': "This subagent's prompt cannot be shown: the engine refused access to its conversation.",
     'session.subagent.delegatedPrompt.absence.promptAbsent': "This subagent's conversation was read, but it holds no delegated prompt to show.",
     'session.subagent.delegatedPrompt.absence.unknown': "This subagent's prompt could not be read just now.",
+    'rules.sessionPolicy.remove.loosenForbiddenStem': 'The engine refused to take these entries out of this session’s rule record, so the record is unchanged: it counts at least one of them as written by an operator rather than added by the session’s owner, and an owner can take back only the entries the owner added.',
+    'rules.sessionPolicy.remove.loosenForbidden': '{stem} Ask an operator to remove them, or continue in a new session.',
     'rules.sessionPolicy.tighten.unknown.sessionOwnerless.noIdentity': 'This session has no owner, so a rule written for it could never be read back; nothing was written.',
     'rules.sessionPolicy.tighten.unknown.storeCorrupt.noOperator': 'The engine could not establish which version this session’s rules are at and refused to stamp a new one, so nothing was written. The entries sent here are not the problem — this deployment has no operator to look at the rule store, so whoever runs it has to.',
     'rules.sessionPolicy.deployment.noOperator.readStoreCorrupt': 'The engine could not establish which version this session’s rules are at, so it would not hand the record over. This deployment has no operator to look at the rule store — whoever runs it has to.',
-    'rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden': 'The engine refused to take these entries out of this session’s rule record: on this engine only an operator can remove entries from it, and this deployment has none, so the record is unchanged. Continue in a new session.',
+    'rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden': '{stem} This deployment has no operator to remove them. Continue in a new session.',
     'rules.sessionPolicy.deployment.noOperator.removeReadStoreCorrupt': 'The engine could not establish which version this session’s rules are at, so nothing was changed. This deployment has no operator to look at the rule store — whoever runs it has to.',
     'rules.sessionPolicy.deployment.noOperator.removeWriteStoreCorrupt': 'The engine could not establish which version this session’s rules are at and refused to stamp a new one, so nothing was changed. This deployment has no operator to look at the rule store — whoever runs it has to.',
     'config.hooks.plan.reason.compactionLocalFallback': 'this compaction is summarized on this client because the engine session is unavailable, so the engine will not run it and this client runs it itself',
     'config.hooks.plan.reason.keyNotRead': 'the connected server does not read a key written on this hook (remove the key, or use a server that reads it)',
     'config.hooks.plan.disableAllHooks': 'All hooks are turned off by managed settings (disableAllHooks).',
+    'config.hooks.plan.reason.closedUntrusted': 'this workspace is not trusted, so no hooks run in it',
+    'config.hooks.plan.reason.closedGovernanceUnreadable': 'the managed policy could not be read, so no hooks run this turn',
+    'config.hooks.plan.reason.closedDisableAll': 'managed settings turn off all hooks (disableAllHooks)',
     'config.hooks.plan.keyNotRead.oneKey': '{layer}: {hooks} will not run — the connected server does not read the key {coordinates}. Remove the key, or use a server that reads it.',
     'config.hooks.plan.keyNotRead.manyKeys': '{layer}: {hooks} will not run — the connected server does not read the keys {coordinates}. Remove those keys, or use a server that reads them.',
     'config.hooks.plan.keyNotRead.more': '{shown} and {rest} more',
@@ -1133,8 +1293,11 @@ const EN = {
     'config.mods.loader.failed': '{name} could not be loaded: {reason}',
     'config.mods.loader.failedNoReason': '{name} could not be loaded',
     'config.mods.refusal.by': 'Refused by {by}',
+    'config.mods.request.by': 'Requested by {by}',
     'config.mods.rewrite.resultInPlace': 'Answered by {by} in place of the tool',
     'config.mods.rewrite.inputBy': 'Arguments changed by {by} before the call was let through',
+    'config.mods.session.unreadable': "The mods used by this conversation's last run couldn't be read",
+    'config.mods.session.unarmed': 'Mods show up here once this conversation has run on this engine',
     'follow.notFollowed.headRun': 'This screen is no longer following run {taskId}{reason}{ending}{exit}',
     'follow.notFollowed.headTurn': "This screen is no longer following this turn's run{reason}{ending}{exit}",
     'follow.notFollowed.reason.exhaustedDraining': ": the engine instance serving it was going down when its last event stream closed, and this client's re-attach allowance has run out.",
@@ -1169,5 +1332,94 @@ const EN = {
     'approval.planReview.decision.gateUntrusted': "The engine could not recognise this review's gate id (the server's record of it looks damaged; an operator should check it). The card still shows the plan that is waiting: answering again sends the answer without the gate id, and that answer is not protected against the plan having changed.",
     'approval.planReview.option.askAgain.label': 'No, ask for the plan to be presented again',
     'approval.planReview.option.askAgain.description': 'Do not approve; ask the model to present the plan again',
+    'localEngine.behind.cliUpdate': 'The local engine (version {running}) is newer than this Sema ({own}), so this Sema cannot start new work on it. Run `sema update`, then reopen this session.',
+    'localEngine.behind.appUpdate': 'The local engine (version {running}) is newer than this Sema ({own}), so this Sema cannot start new work on it. Update this app to version {running} or later, then restart it.',
+    'localEngine.versionUnknown': "The local engine's version could not be read, so it will not be replaced automatically.",
+    'localEngine.legacyBelowFloor': 'The local engine (version {running}) is older than the oldest version this Sema supports ({floor}); it has to be replaced before this Sema can use it.',
+    'localEngine.card.title.version': 'Replace the local engine with the newer version?',
+    'localEngine.card.title.config': 'Restart the local engine to apply the changed configuration?',
+    'localEngine.card.title.credential': 'Restart the local engine to use the changed credentials?',
+    'localEngine.card.title.modelDefault': 'Restart the local engine to apply the changed default model?',
+    'localEngine.card.title.user': 'Restart the local engine now?',
+    'localEngine.card.title.unresponsive': 'The local engine is not responding. Restart it?',
+    'localEngine.card.versions': 'Running engine: version {running}. This Sema: version {own}.',
+    'localEngine.card.others.one': '{total} other Sema client is using the engine ({midTurn} in the middle of a turn).',
+    'localEngine.card.others.other': '{total} other Sema clients are using the engine ({midTurn} in the middle of a turn).',
+    'localEngine.card.others.unknown': 'Other Sema clients using the engine: could not be read.',
+    'localEngine.card.inflight.one': '{count} run is in progress on the engine.',
+    'localEngine.card.inflight.other': '{count} runs are in progress on the engine.',
+    'localEngine.card.inflight.unknown': 'Runs in progress on the engine: could not be read.',
+    'localEngine.card.background.one': '{count} background task or workflow is running.',
+    'localEngine.card.background.other': '{count} background tasks or workflows are running.',
+    'localEngine.card.background.unknown': 'Background tasks and workflows: could not be read.',
+    'localEngine.card.overlap': 'A run that is running in the background may be counted in both lines above.',
+    'localEngine.card.selfUnknown': 'What this Sema is doing right now could not be read.',
+    'localEngine.card.parked': "If you go ahead now, work in progress ends by being parked or interrupted. Parked work continues under the engine's durable resume, the same guarantee as when the engine stops on its own; until it is resumed or cancelled in its session, new messages to that session are refused.",
+    'localEngine.card.force': 'Go ahead now: work in progress ends within about {seconds} seconds.',
+    'localEngine.card.wait': 'Not now: the current engine keeps running.',
+    'localEngine.exitFate.peers': 'The local engine keeps running: other Sema clients are still using it.',
+    'localEngine.exitFate.lease': 'The local engine keeps running for now and stops by itself once nothing is using it.',
+    'localEngine.exitFate.unknown': 'The local engine keeps running; whether other Sema clients are still using it could not be read.',
+    'localEngine.principalOverrideIgnored': 'The principal set in the environment (`SEMA_LIVE_PRINCIPAL`) does not apply to the local engine; Sema uses the one in the env block of your settings, so every Sema app on this computer acts as the same principal. To change it, change it in your settings.',
+    'localEngine.principalUnknown': 'Sema could not read {layer}, so local sessions are paused: the principal they run as may be set there. Fix that file, then restart Sema.',
+    'localEngine.settingsLayer.userSettings': 'your settings file',
+    'localEngine.settingsLayer.flagSettings': 'the settings file given at startup',
+    'localEngine.settingsLayer.policySettings': 'the managed settings',
+    'localEngine.settingsLayer.unspecified': 'a settings file',
+    'localEngine.bootRefusal': 'The local engine refused to start: {reason}',
+    'localEngine.firstShare': "Sema now shares one local engine with the other Sema apps on this computer. Local sessions from this app's earlier private engine are not shown in the list; their data has been left in place.",
+    'localEngine.phase.starting': 'Starting the local engine…',
+    'localEngine.phase.dormant': 'The local engine is not running; it starts when a session needs it.',
+    'localEngine.phase.draining': 'The local engine is finishing its work before it stops; Sema reconnects when it is back.',
+    'localEngine.phase.unanswered': "A process holds the local engine's port but is not answering; Sema is waiting for it.",
+    'localEngine.phase.unverifiable': "A process answers on the local engine's port but its identity cannot be verified, so Sema neither starts a second engine nor stops it.",
+    'localEngine.phase.pendingBlocked': 'This Sema cannot use the running local engine until it is replaced.',
+    'localEngine.phase.swappingIdle': 'Replacing the local engine while nothing is using it…',
+    'localEngine.phase.swappingForced': 'Replacing the local engine now; work in progress is being parked or interrupted.',
+    'localEngine.waitingPeer': 'Another Sema is starting or replacing the local engine; waiting for it.',
+    'localEngine.banner.pending': 'A local engine restart is pending; it happens once nothing is using the engine.',
+    'localEngine.down.lockUnavailable': 'Another Sema holds the local engine start lock and did not finish in time; try again.',
+    'localEngine.down.spawnFailed': 'The local engine did not start.',
+    'localEngine.down.spawnRefused': 'The local engine was not started: the preparation step did not pass.',
+    'localEngine.down.stopFailed': 'The old local engine did not stop in time, so it was not replaced.',
+    'localEngine.down.crashLoop': 'The local engine keeps stopping unexpectedly, so automatic restarts are paused.',
+    'localEngine.down.highWaterUnreadable': 'The record of the newest engine version used on this machine cannot be read, so the local engine is not started; check the engine data directory.',
+    'localEngine.crashLoop.retry': 'The local engine keeps stopping unexpectedly; Sema tries again in about {seconds} seconds.',
+    'localEngine.crashLoop.stopped': 'The local engine keeps stopping unexpectedly; Sema has stopped retrying on its own. Restart it manually.',
+    'localEngine.crashLoop.retrying': 'Trying to start the local engine again.',
+    'localEngine.drainOverdue': 'The local engine is taking longer than expected to finish its work.',
+    'localEngine.engineExited.unexpected': 'The local engine stopped unexpectedly; Sema starts it again when it is needed.',
+    'localEngine.engineExited.crashLoop': 'The local engine stopped unexpectedly again; automatic restarts are paused.',
+    'localEngine.engineExited.quiet': 'The local engine exited; Sema starts it again when it is needed.',
+    'localEngine.cannotVerifyEngine': 'The running local engine cannot be verified, so Sema will not stop it.',
+    'localEngine.lockUnavailable': 'Another Sema holds the local engine start lock; the current engine keeps running.',
+    'localEngine.prepareFailed.reason': 'The local engine was not replaced; the current engine keeps running. Reason: {reason}',
+    'localEngine.prepareFailed.timeout': 'The local engine was not replaced because preparing the replacement took too long; the current engine keeps running.',
+    'localEngine.spawnFailed.timeout': 'The new local engine did not answer in time.',
+    'localEngine.lockLost': 'Sema lost the local engine start lock; it sends no further signals and checks again.',
+    'localEngine.forcedLine': 'The local engine was replaced now; work that was in progress was parked or interrupted.',
+    'localEngine.headless.behind': 'The local engine is newer than this Sema; update Sema and run the command again.',
+    'localEngine.headless.legacyBelowFloor': 'The local engine is older than this Sema supports; open Sema interactively to replace it, then run the command again.',
+    'localEngine.headless.unresponsive': 'The local engine is not responding; open Sema interactively to restart it, then run the command again.',
+    'localEngine.headless.swapPending': 'The local engine has to be restarted before this command can run; open Sema interactively to confirm, then run the command again.',
+    'localEngine.headless.drainOverdue': 'The local engine did not finish stopping in time; run the command again later.',
+    'localEngine.headless.unverifiable': "A process answers on the local engine's port but its identity cannot be verified; the command stops here.",
+    'localEngine.restartOutcome.skippedNoDemand': 'The change takes effect the next time the local engine starts.',
+    'localEngine.restartOutcome.pendingCard': 'Other sessions are using the local engine; confirm the restart on the card.',
+    'localEngine.restartOutcome.pendingBusy': 'Other sessions are using the local engine; it restarts once nothing is using it.',
+    'localEngine.restartOutcome.failedPrepare': 'The local engine was not restarted; the current engine keeps running.',
+    'localEngine.restartOutcome.failedDown': 'The local engine could not be restarted: {detail}',
+    'session.devices.repoint.done': "Done: this machine's device record and sessions now follow the new engine address. The device kept its identity — nothing was enrolled again.",
+    'session.devices.repoint.unverified': "Nothing was changed: the new address could not be confirmed to hold this device. If it is the same engine, check that you are signed in as the device's owner and try again. Otherwise enroll this machine again at the engine's own address, then remove the old device from the engine's device list.",
+    'session.devices.repoint.undetermined': "Nothing was changed: a check against the new address could not be read, so it is not known whether this device is registered there. Try again. Or enroll this machine again at the engine's own address, then remove the old device from the engine's device list.",
+    'session.devices.repoint.partial': 'The device record now follows the new address, but not every session could be updated. Run the same command again to finish — sessions that were already updated are left as they are.',
+    'session.devices.repoint.storeFailed': "The device record could not be moved, so nothing was changed. Run the command again; if it keeps failing, enroll this machine again at the engine's own address.",
+    'session.devices.repoint.refused.addressInvalid': 'Nothing was changed: an address is not usable. Give the full https:// address of the engine (plain http:// is only accepted for this machine).',
+    'session.devices.repoint.refused.sameAddress': 'Nothing was changed: the new address is the same engine address as the old one.',
+    'session.devices.repoint.refused.recordAbsent': 'Nothing was changed: this machine has no device record for the old address.',
+    'session.devices.repoint.refused.recordNotActive': "Nothing was changed: the device record for this address is not an active enrollment (it is still being enrolled, or the device was removed). Enroll again at the engine's own address.",
+    'session.devices.repoint.refused.recordUnreadable': 'Nothing was changed: a device record could not be read, so it was left alone.',
+    'session.devices.repoint.refused.targetOccupied': 'Nothing was changed: this machine already has a different device record for the new address.',
+    'session.devices.repoint.refused.unarmed': 'Nothing was changed: this app is not set up to move the device record and its sessions.',
 };
 export const EN_MESSAGES = Object.freeze(EN);