@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/hostTurnSettings.js

@@ -1,7 +1,7 @@
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
 import { hostLog } from './host.js';
 import { layerNotAppliedRefusesTurn, salvageSettingsHooksEntries } from './settingsHooksSalvage.js';
-import { ADOPTED_LAYERS, HOST_SETTINGS_LAYERS, HostSettingsSourceShapeError, permissionRulesOf, MANAGED_READING_DISPOSITIONS, adoptHostSettingsRead, mintHostSettingsSession, readHostSettingsOnce, remintSameContent, sessionSnapshotOf, settingsValueOf, sourceOfRead, } from './hostSettingsSource.js';
+import { ADOPTED_LAYERS, HOST_SETTINGS_LAYERS, HostSettingsSourceShapeError, TIGHTEN_ONLY_HOST_SETTINGS_LAYERS, permissionBucketOf, permissionRulesOf, MANAGED_READING_DISPOSITIONS, adoptHostSettingsRead, mintHostSettingsSession, readHostSettingsOnce, remintSameContent, sessionSnapshotOf, settingsValueOf, sourceOfRead, } from './hostSettingsSource.js';
 import { hooksWirePlan } from './hooksWireCaps.js';
 import { submissionSurfaceOf } from './request/submissionIdentity.js';
 import { displayUntrusted } from './displayUntrusted.js';
@@ -11,7 +11,8 @@ import { msg, renderMessage } from './i18n/translate.js';
 import { newRulePortsProjection, projectPermissionsDeclaration, rulePortsMissingOf, WIRE_RULE_TRUST_ORDER } from './permissionsDeclaration.js';
 import { assemblyRefusalOf } from './wireFailureShape.js';
 import { permissionRuleLayersOn } from './permissionsAllowGrantCapability.js';
-import { layerAdmitted } from './settingsLayerAdmission.js';
+import { layerAdmissionReading, layerAdmitted } from './settingsLayerAdmission.js';
+import { SETTINGS_BUILD_LAYER_PARTS_UNREAD_NOTICE } from './generated/settingsSchemaFns.js';
 import { appendOwnElement, ownDataField } from './ownKey.js';
 export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
 export const HOST_SETTING_CAUSES = Object.freeze([
@@ -42,6 +43,7 @@ const HOST_SETTING_NOTICE_TEXT = {
     'HS-HELD-PREVIOUS': () => renderMessage(msg('session.hostSettings.heldPrevious')),
     'HS-STYLE-MISSING': (what) => renderMessage(msg('session.hostSettings.styleMissing', { name: what })),
     'HS-STYLE-SAFE': () => renderMessage(msg('session.hostSettings.styleSafeMode')),
+    'HS-LAYER-PARTS-UNREAD': (line) => line,
 };
 const KEY_NOUN = {
     'settings.hooks': 'the hooks',
@@ -367,10 +369,60 @@ function stringListOf(v) {
 function permissionMemberAdmitted(layer, read, bucket) {
     return layerAdmitted(layer, read.trust, 'permissions', bucket);
 }
+function managedRulesOnly(read) {
+    const policyDoc = read.layers.policySettings.doc;
+    return MANAGED_READING_DISPOSITIONS[read.managed].ruleScope === 'by-switch' && policyDoc !== null && managedOnlySwitchOn(policyDoc);
+}
+const TIGHTEN_ONLY_LAYER_BUCKETS = Object.freeze(['deny', 'ask']);
+function tightenOnlyBucketsRead(read, layer) {
+    if (managedRulesOnly(read))
+        return [];
+    const doc = read.layers[layer].doc;
+    return TIGHTEN_ONLY_LAYER_BUCKETS.filter((bucket) => permissionMemberAdmitted(layer, read, bucket) && permissionBucketOf(doc, bucket) !== undefined);
+}
+function tightenOnlyLayerPartsUnread(read, layer, permissionsRead) {
+    const doc = read.layers[layer].doc;
+    if (doc === null)
+        return [];
+    const readBuckets = permissionsRead ? tightenOnlyBucketsRead(read, layer) : [];
+    const parts = [];
+    const rec = doc;
+    for (const key of Object.keys(rec)) {
+        const v = rec[key];
+        if (key !== 'permissions')
+            appendOwnElement(parts, key);
+        else if (typeof v !== 'object' || v === null || Array.isArray(v))
+            appendOwnElement(parts, key);
+        else
+            for (const member of Object.keys(v))
+                if (!readBuckets.includes(member))
+                    appendOwnElement(parts, `${key}.${member}`);
+    }
+    for (const c of read.layers[layer].carriers)
+        if (c.status === 'loaded-partial')
+            for (const k of c.issues ?? [])
+                if (!parts.includes(k))
+                    appendOwnElement(parts, k);
+    return parts;
+}
+function tightenOnlyLayerNotices(read, permissionsRead) {
+    const out = [];
+    for (const layer of TIGHTEN_ONLY_HOST_SETTINGS_LAYERS) {
+        const snap = read.layers[layer];
+        if (!snap.enabled || snap.doc === null)
+            continue;
+        const parts = tightenOnlyLayerPartsUnread(read, layer, permissionsRead);
+        const loaded = snap.carriers.filter((c) => c.status === 'loaded' || c.status === 'loaded-partial').map((c) => c.id);
+        const file = (loaded.length > 0 ? loaded : snap.carriers.map((c) => c.id)).join(', ');
+        const n = SETTINGS_BUILD_LAYER_PARTS_UNREAD_NOTICE({ source: layer, workspace: layerAdmissionReading(read.trust), file, parts });
+        if (n !== undefined)
+            appendOwnElement(out, notice('HS-LAYER-PARTS-UNREAD', 'session', displayUntrusted(n.line)));
+    }
+    return out;
+}
 function allowAdmittedFor(read) {
     const disp = MANAGED_READING_DISPOSITIONS[read.managed];
-    const policyDoc = read.layers.policySettings.doc;
-    const managedOnlySwitch = disp.ruleScope === 'by-switch' && policyDoc !== null && managedOnlySwitchOn(policyDoc);
+    const managedOnlySwitch = managedRulesOnly(read);
     const degrade = disp.ruleScope === 'degrade';
     return (layer) => {
         if (degrade || managedOnlySwitch)
@@ -387,7 +439,7 @@ function allowAdmittedFor(read) {
     };
 }
 function badPermissionsSource() {
-    return new HostSourceShapeError(`hostTurnSettings: sources.resolved must be 'none' or { allowGrantReading, cliArg?, session?, clientOwnedServers?, serverVersion? } — since 0.101.0 the permission rules of the settings files come from the settings the entry reads; do not pass snapshot — got something else (the value is not echoed).`);
+    return new HostSourceShapeError(`hostTurnSettings: sources.resolved must be 'none' or { allowGrantReading, cliArg?, session?, clientOwnedServers? } — since 0.101.0 the permission rules of the settings files come from the settings the entry reads; do not pass snapshot — got something else (the value is not echoed).`);
 }
 function readPermissionSource(src) {
     const key = 'settings.resolved';
@@ -405,12 +457,9 @@ function readPermissionSource(src) {
     let sesAsk;
     let owned;
     let ownedRaw;
-    let serverVersion;
     try {
         if (!isRecordShape(v) || Object.hasOwn(v, 'snapshot') || !Object.hasOwn(v, 'allowGrantReading'))
             throw badPermissionsSource();
-        const sver = ownDataOf(v, 'serverVersion');
-        serverVersion = sver.ok && typeof sver.value === 'string' ? sver.value : undefined;
         const g = ownDataOf(v, 'allowGrantReading');
         const c = ownDataOf(v, 'cliArg');
         const se = ownDataOf(v, 'session');
@@ -444,13 +493,13 @@ function readPermissionSource(src) {
     }
     if (cliAllow === undefined || cliDeny === undefined || sesDeny === undefined || sesAsk === undefined || (owned === undefined && ownedRaw !== undefined))
         throw badPermissionsSource();
-    return { kind: 'facts', allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned, serverVersion };
+    return { kind: 'facts', allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned };
 }
 function permissionsArm(facts, side, adoption, layered) {
     const key = 'settings.resolved';
     if (facts.kind === 'arm')
         return facts.arm;
-    const { allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned, serverVersion } = facts;
+    const { allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned } = facts;
     if (side.kind === 'missing')
         return missingArm(key);
     const buckets = { deny: [], ask: [], allow: [] };
@@ -482,7 +531,7 @@ function permissionsArm(facts, side, adoption, layered) {
         const read = side.read;
         const disp = MANAGED_READING_DISPOSITIONS[read.managed];
         const policyDoc = read.layers.policySettings.doc;
-        const managedOnlySwitch = disp.ruleScope === 'by-switch' && policyDoc !== null && managedOnlySwitchOn(policyDoc);
+        const managedOnlySwitch = managedRulesOnly(read);
         const degrade = disp.ruleScope === 'degrade';
         try {
             for (const bucket of Object.keys(buckets)) {
@@ -506,6 +555,10 @@ function permissionsArm(facts, side, adoption, layered) {
                     for (const r of adoption?.extraTighten[bucket] ?? [])
                         if (permissionMemberAdmitted(r.layer, read, bucket))
                             add(bucket, r.rule, r.layer);
+                for (const l of TIGHTEN_ONLY_HOST_SETTINGS_LAYERS)
+                    for (const bucket of tightenOnlyBucketsRead(read, l))
+                        for (const r of permissionRulesOf(read.layers[l].doc, bucket))
+                            add(bucket, r, l);
             }
         }
         catch (error) {
@@ -521,7 +574,7 @@ function permissionsArm(facts, side, adoption, layered) {
     let declared;
     if (projectionError === undefined) {
         try {
-            const d = projectPermissionsDeclaration({ deny: buckets.deny, ask: buckets.ask, allow: buckets.allow, origins, cliDeny, settingsRead: 'clean', ...(owned !== undefined && owned.length > 0 ? { clientOwnedServers: owned } : {}), ...(serverVersion !== undefined ? { serverVersion } : {}) }, allowGrantReading, portsProjection, layered ? freeze({ deny: freeze([...contributions.deny]), ask: freeze([...contributions.ask]) }) : undefined);
+            const d = projectPermissionsDeclaration({ deny: buckets.deny, ask: buckets.ask, allow: buckets.allow, origins, cliDeny, settingsRead: 'clean', ...(owned !== undefined && owned.length > 0 ? { clientOwnedServers: owned } : {}) }, allowGrantReading, portsProjection, layered ? freeze({ deny: freeze([...contributions.deny]), ask: freeze([...contributions.ask]) }) : undefined);
             declared = d.permissions !== undefined ? { permissions: d.permissions } : undefined;
         }
         catch (error) {
@@ -584,8 +637,11 @@ function notLoadedLayers(read, plan) {
     }
     return out;
 }
+const isTightenOnlyLayer = (l) => TIGHTEN_ONLY_HOST_SETTINGS_LAYERS.includes(l);
 function notLoadedSentence(n, form) {
     const layer = msg(`session.hostSettings.layer.${n.layer}`);
+    if (isTightenOnlyLayer(n.layer))
+        return renderMessage(msg(form === 'hold' ? 'session.hostSettings.layerNotLoaded.restrictions.hold' : 'session.hostSettings.layerNotLoaded.restrictions.sent', { layer }));
     return renderMessage(msg(form === 'hold' ? `session.hostSettings.layerNotLoaded.hold.${n.how}` : 'session.hostSettings.layerNotLoaded.sent.unreadable', { layer }));
 }
 function settingsSideOf(input) {
@@ -679,17 +735,19 @@ export function buildHostTurnSettings(input, judges) {
     if (notLoaded.length > 0) {
         const key = `hs1-${fnv1a(JSON.stringify(notLoaded.map((n) => n.key)))}`;
         const ask = surface === 'interactive' && !session.consented.includes(key);
-        const layers = freeze(notLoaded.map((n) => n.layer));
-        const cause = notLoaded.some((n) => n.how === 'unreadable') ? 'source_unreadable' : 'source_rejected';
-        const reshape = (a) => {
+        const reshape = (a, feeds) => {
             const d = a.row.disposition;
             if (d === 'refuse_turn' || d === 'unwired' || a.row.cause === 'no_source')
                 return a;
+            const mine = notLoaded.filter((n) => feeds(n.layer));
+            if (mine.length === 0)
+                return a;
+            const cause = mine.some((n) => n.how === 'unreadable') ? 'source_unreadable' : 'source_rejected';
             const disposition = ask ? 'hold_for_consent' : a.carried !== undefined ? 'carry_partial' : 'withhold_notice';
-            return { ...a, row: freeze({ key: a.row.key, cause, disposition, layers }) };
+            return { ...a, row: freeze({ key: a.row.key, cause, disposition, layers: freeze(mine.map((n) => n.layer)) }) };
         };
         const before = armsByKey;
-        armsByKey = [{ ...reshape(before[0]), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, reshape(before[1]), before[2], before[3], before[4], before[5]];
+        armsByKey = [{ ...reshape(before[0], (l) => !isTightenOnlyLayer(l)), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, reshape(before[1], () => true), before[2], before[3], before[4], before[5]];
         if (ask && armsByKey.slice(0, 2).some((a) => a.row.disposition === 'hold_for_consent'))
             consentKey = key;
         for (const n of notLoaded) {
@@ -709,7 +767,11 @@ export function buildHostTurnSettings(input, judges) {
     }
     const arms = armsByKey;
     const rows = freeze(arms.map((a) => a.row));
-    const notices = freeze([...arms.flatMap((a) => a.notices), ...notLoadedNotices, ...heldNotices]);
+    const resolvedOut = arms[1]?.row.disposition === 'carry' || arms[1]?.row.disposition === 'carry_partial' || arms[1]?.row.disposition === 'hold_for_consent' ? resolvedCarried : undefined;
+    const permissionsRow = arms[1]?.row;
+    const permissionsRead = permissionsRow !== undefined && permissionsRow.disposition !== 'refuse_turn' && permissionsRow.disposition !== 'unwired' && permissionsRow.cause !== 'no_source';
+    const partsNotices = side.kind === 'read' ? tightenOnlyLayerNotices(side.read, permissionsRead) : [];
+    const notices = freeze([...arms.flatMap((a) => a.notices), ...notLoadedNotices, ...heldNotices, ...partsNotices]);
     const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
     const verdict = refusal !== undefined
         ? freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notices.find((n) => n.plane === 'turn') ?? notice('HS-PROJECTION', 'turn') })
@@ -721,7 +783,6 @@ export function buildHostTurnSettings(input, judges) {
         return a.row.disposition === 'carry' || a.row.disposition === 'carry_partial' || a.row.disposition === 'hold_for_consent' ? a.carried : undefined;
     };
     const hooksCarried = carriedOf(0);
-    const resolvedOut = arms[1]?.row.disposition === 'carry' || arms[1]?.row.disposition === 'carry_partial' || arms[1]?.row.disposition === 'hold_for_consent' ? resolvedCarried : undefined;
     const carried = freeze({
         ...(hooksCarried !== undefined ? { hooks: hooksCarried } : {}),
         ...(resolvedOut !== undefined ? { resolved: resolvedOut } : {}),

package/dist/i18n/messages.en.d.ts

@@ -122,6 +122,11 @@ declare const EN: {
     'session.devices.probeFailedTransport': string;
     'session.devices.probeFailedRefused': string;
     'session.devices.probeFailedUnreadable': string;
+    'session.engine.selfNotLocal': string;
+    'session.engine.dispatch.notWired': string;
+    'session.engine.dispatch.scopeMismatch': string;
+    'session.engine.dispatch.scopeUnproven': string;
+    'session.engine.dispatch.unresolved': string;
     'config.cloudLogin.accessDenied': string;
     'config.cloudLogin.expiredToken': string;
     'config.cloudLogin.invalidGrant': string;
@@ -141,6 +146,7 @@ declare const EN: {
     'config.engineTarget.loginFailed': string;
     'config.engineTarget.storageUnavailable': string;
     'config.engineTarget.noLocalRuntime': string;
+    'config.engineTarget.serverBelowSupportFloor': string;
     'config.engineTarget.input': string;
     'config.engineTarget.unknown': string;
     'onboard.probe.endpointReachable': string;
@@ -240,6 +246,11 @@ declare const EN: {
     'approval.settle.cause.broadcastLost': string;
     'approval.settle.cause.streamDisconnected': string;
     'approval.settle.cause.undeliverable': string;
+    'approval.decide.requiresBinding': string;
+    'approval.decide.unboundWayOut': string;
+    'approval.rowUnresumable.fallback': string;
+    'approval.rowUnresumable.askNotSurfaced': string;
+    'approval.park.stillParked': string;
     'approval.decision.grantChanged': string;
     'approval.decision.settledElsewhereContrary.deniedFirst': string;
     'approval.decision.settledElsewhereContrary.approvedFirst': string;
@@ -295,6 +306,13 @@ declare const EN: {
     'session.crashConverged.cause.neutral': string;
     'session.crashConverged.cause.withClause': string;
     'session.corrupt.content': string;
+    'session.projectSeed.invalid': string;
+    'session.projectSeed.invalidAt': string;
+    'session.projectSeed.laneNotIsolated': string;
+    'session.projectSeed.seedFixed': string;
+    'session.projectSeed.boundElsewhere': string;
+    'session.projectSeed.laneUnknown': string;
+    'session.projectSeed.missing': string;
     'resume.reopen.first.envFailed': string;
     'resume.reopen.first.toolUnavailable': string;
     'resume.reopen.first.toolContractMismatch': string;
@@ -394,6 +412,8 @@ declare const EN: {
     'session.selfHeal.injected.handedOffWatch': string;
     'session.selfHeal.injected.interruptedFinishing': string;
     'session.selfHeal.injected.notDelivered': string;
+    'session.selfHeal.injected.redundant': string;
+    'session.selfHeal.injected.deferred': string;
     'session.selfHeal.decisionInFlight': string;
     'session.selfHeal.parkedOn.ask': string;
     'session.selfHeal.parkedOn.plan': string;
@@ -406,6 +426,7 @@ declare const EN: {
     'session.selfHeal.row.askDecided.inferred': string;
     'session.selfHeal.row.askDecided.releaseUnknown': string;
     'session.selfHeal.row.askReopenFailed.withKeep': string;
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': string;
     'session.selfHeal.row.askReopenFailed.noKeep': string;
     'session.selfHeal.row.planReopenFailed.dismissed': string;
     'session.selfHeal.row.planReopenFailed.withKeep': string;
@@ -545,6 +566,11 @@ declare const EN: {
     'approval.boundGrants.denyPart.one': string;
     'approval.boundGrants.denyPart.other': string;
     'approval.boundGrants.activates': string;
+    'approval.boundGrants.allowPart.named.one': string;
+    'approval.boundGrants.allowPart.named.other': string;
+    'approval.boundGrants.denyPart.named.one': string;
+    'approval.boundGrants.denyPart.named.other': string;
+    'approval.boundGrants.more': string;
     'session.fileHistoryRefusal.notYet': string;
     'session.fileHistoryRefusal.notSaid': string;
     'session.fileHistoryRefusal.unrecognized': string;
@@ -556,6 +582,12 @@ declare const EN: {
     'session.memorySync.parkedUnnamed.other': string;
     'session.memorySync.wayOut.deleteCursor': string;
     'session.memorySync.wayOut.unrecognized': string;
+    'session.memorySyncTrigger.notConfigured': string;
+    'session.memorySyncTrigger.noSettledRun': string;
+    'session.memorySyncTrigger.runUnobserved': string;
+    'session.memorySyncTrigger.memoryNotMounted': string;
+    'session.memorySyncTrigger.noLeaf': string;
+    'session.memorySyncTrigger.unobtainable': string;
     'session.hostSettings.memorySwitchMalformed': string;
     'session.hostSettings.fileHistoryRestoreConflict': string;
     'session.hostSettings.projectionUnchecked': string;
@@ -565,11 +597,14 @@ declare const EN: {
     'session.hostSettings.layerNotLoaded.hold.unreadable': string;
     'session.hostSettings.layerNotLoaded.hold.rejected': string;
     'session.hostSettings.layerNotLoaded.sent.unreadable': string;
+    'session.hostSettings.layerNotLoaded.restrictions.hold': string;
+    'session.hostSettings.layerNotLoaded.restrictions.sent': string;
     'session.hostSettings.layer.policySettings': string;
     'session.hostSettings.layer.userSettings': string;
     'session.hostSettings.layer.projectSettings': string;
     'session.hostSettings.layer.localSettings': string;
     'session.hostSettings.layer.flagSettings': string;
+    'session.hostSettings.layer.foreignProjectSettings': string;
     'session.hostSettings.heldPrevious': string;
     'session.hostSettings.styleMissing': string;
     'session.hostSettings.styleSafeMode': string;
@@ -603,7 +638,6 @@ declare const EN: {
     'rules.refusal.list.more': string;
     'rules.refusal.reason.toolName': string;
     'rules.refusal.reason.homePath': string;
-    'rules.refusal.reason.neverMatches': string;
     'rules.nearMiss.sentence.one': string;
     'rules.nearMiss.sentence.other': string;
     'rules.nearMiss.reason': string;
@@ -734,17 +768,6 @@ declare const EN: {
     'notice.capability.hands.unknownRosterUnreadable': string;
     'notice.capability.hands.unknownMountConditionAbsent': string;
     'rules.sessionPolicy.tighten.written': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.counts': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unreadable': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unseen': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.one': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.many': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.one': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.many': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.one': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.many': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.two': string;
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.three': string;
     'rules.sessionPolicy.tighten.conflict': string;
     'rules.sessionPolicy.tighten.loosenForbidden': string;
     'rules.sessionPolicy.tighten.capabilityAbsent': string;
@@ -965,6 +988,7 @@ declare const EN: {
     'notice.wireRefusal.hostPosture.both': string;
     'notice.wireRefusal.hostPosture.unattributed': string;
     'notice.wireRefusal.autonomyLane': string;
+    'notice.wireRefusal.sessionArchiveStamped': string;
     'notice.wireRefusal.unsupportedRule': string;
     'notice.wireRefusal.unsupportedRule.other': string;
     'notice.wireRefusal.unsupportedRule.stored': string;
@@ -1101,6 +1125,11 @@ declare const EN: {
     'approval.planReview.askAgain.notCarried': string;
     'approval.planReview.askAgain.unknown': string;
     'approval.planReview.askAgain.withNote': string;
+    'approval.planReview.decision.notSent': string;
+    'approval.planReview.decision.refused': string;
+    'approval.planReview.decision.cardMissing': string;
+    'approval.planReview.decision.gateMoved': string;
+    'approval.planReview.decision.gateUntrusted': string;
     'approval.planReview.option.askAgain.label': string;
     'approval.planReview.option.askAgain.description': string;
 };

package/dist/i18n/messages.en.js

@@ -122,6 +122,11 @@ 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.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.",
     '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.',
@@ -141,6 +146,7 @@ const EN = {
     'config.engineTarget.loginFailed': 'Sign-in failed.',
     'config.engineTarget.storageUnavailable': "Secure storage isn't available on this device, so the Cloud credential can't be kept. Nothing was changed.",
     'config.engineTarget.noLocalRuntime': "There's no local engine on this device.",
+    'config.engineTarget.serverBelowSupportFloor': 'This server reports version {version}, older than {floor} — the oldest server this client supports. Requests to it may be refused or not behave as described; connect to a server at {floor} or newer.',
     'config.engineTarget.input': "The request wasn't in the expected shape, so nothing was changed.",
     'config.engineTarget.unknown': "The engine switch didn't go through.",
     'onboard.probe.endpointReachable': '{method} {path} → {status} (endpoint reachable)',
@@ -240,6 +246,11 @@ const EN = {
     'approval.settle.cause.broadcastLost': 'it never reached any open connection',
     'approval.settle.cause.streamDisconnected': 'the connection carrying this card dropped',
     'approval.settle.cause.undeliverable': 'it could not be delivered to any approval surface',
+    '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': 'it cannot be decided here — cancel the run or let the approval expire',
+    'approval.rowUnresumable.fallback': 'this engine does not report that it can continue this pending approval, so it was not shown as a card that can be approved; nothing was sent',
+    '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.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.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.',
@@ -295,6 +306,13 @@ const EN = {
     'session.crashConverged.cause.neutral': 'the decision converged automatically',
     'session.crashConverged.cause.withClause': '{clause}, and the decision converged automatically',
     'session.corrupt.content': "This session's saved history cannot be read — its stored log is damaged — so the engine cannot open this session. Retrying will not help: whoever operates this engine has to repair or remove that stored log. Until then, continue in a new session.",
+    'session.projectSeed.invalid': 'The project package was refused: it is not a usable project archive. It has to be a gzip tar of the project folder within the size and entry limits, holding only regular files, folders and links that stay inside the folder, each path once, and nothing named .git or attachments at the top level. Fix the folder and upload it again.',
+    'session.projectSeed.invalidAt': '{sentence} Problem entry: {path}',
+    'session.projectSeed.laneNotIsolated': 'The execution lane for this session is not a sandbox, so a project package cannot become its workspace. Hand off a project with a pushed git commit instead, or run the session on a sandboxed lane.',
+    'session.projectSeed.seedFixed': 'A session can start from only one project package: this session already has one, or this submission carried more than one. Send a single package, or start a new session to begin from a different one.',
+    'session.projectSeed.boundElsewhere': 'This upload is already bound to another session, and an upload cannot be moved to a different session, so this submission was not accepted. Upload the project package again for this session.',
+    'session.projectSeed.laneUnknown': 'The engine has not said whether it runs sessions in a sandbox, so a project package cannot be offered as the workspace yet.',
+    'session.projectSeed.missing': 'Upload the project package before handing the session off.',
     'resume.reopen.first.envFailed': 'The execution environment for this parked work could not be brought back',
     'resume.reopen.first.toolUnavailable': 'The tool this approval was granted for is not available on this engine',
     'resume.reopen.first.toolContractMismatch': 'The tool this approval was granted for has changed since the approval was recorded',
@@ -394,6 +412,8 @@ const EN = {
     'session.selfHeal.injected.handedOffWatch': '{lead} was passed to the reply already in progress{id} instead of starting a new one — watch that reply for what it does with it.',
     'session.selfHeal.injected.interruptedFinishing': '{lead} was not delivered: the earlier reply{id} that was stopped is still finishing, so sema did not send it and did not retry — the model has not seen it. Give it a moment, then try again.',
     'session.selfHeal.injected.notDelivered': '{lead} was not delivered: this session was still busy with an earlier reply{id}, and there was no open card you could answer to free it{noView}. sema did not retry, so the model has not seen it.',
+    'session.selfHeal.injected.redundant': '{lead} was not passed on: the reply it was about{id} resumed on its own after that decision, so it has nothing to add.',
+    'session.selfHeal.injected.deferred': '{lead} is waiting: this session is busy with an earlier reply{id}, so sema kept the message and will send it as a new message once that reply has finished or paused.',
     'session.selfHeal.decisionInFlight': 'The previous turn is parked {parkedOn} and your answer to that card is still on its way to the engine, so sema did not show the card again — answering it a second time would send a second decision. It did NOT cancel the run. Your message was NOT sent; send it again in a moment, once the engine has applied that decision.',
     'session.selfHeal.parkedOn.ask': 'waiting for your decision (run {taskId})',
     'session.selfHeal.parkedOn.plan': 'on a plan review (run {taskId})',
@@ -406,6 +426,7 @@ const EN = {
     'session.selfHeal.row.askDecided.inferred': 'The previous turn was parked on an approval that your permission rules decided on their own (no card was needed); run {taskId} resumed and has since finished — sema is re-sending your message; if that run has not fully let go of the session yet, you may have to send it once more.',
     'session.selfHeal.row.askDecided.releaseUnknown': 'The previous turn was parked on an approval that your permission rules decided on their own (no card was needed), so run {taskId} should be resuming{status}. sema could not yet confirm it finished, so your message was not sent — wait a moment and send it again.',
     'session.selfHeal.row.askReopenFailed.withKeep': 'The previous turn is parked waiting for your decision (run {taskId}) and sema could not reopen that card here{noView}. It did NOT cancel the run — that would have decided it for you. Your message was NOT sent. To keep this conversation, {keep}: the card comes back when the session resumes, if it is still waiting. Or {wayOut} if you no longer want it.{viaEngine}',
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': 'The previous turn is parked waiting for your decision (run {taskId}), but this engine cannot continue that pending request, so there is no card to reopen: {sentence} · {unbound}. It did NOT cancel the run. Your message was NOT sent.',
     'session.selfHeal.row.askReopenFailed.noKeep': 'The previous turn is parked waiting for your decision (run {taskId}) and sema could not reopen that card here{noView}. It did NOT cancel the run — that would have decided it for you. Your message was NOT sent; {wayOut} if you no longer want it.{viaEngine}',
     'session.selfHeal.row.planReopenFailed.dismissed': 'The previous turn is parked waiting for a plan review (run {taskId}), and you closed its approval card — {closed}. It did NOT cancel the run — that would have discarded the plan for you. Your message was NOT sent; send it again to bring the card back.',
     'session.selfHeal.row.planReopenFailed.withKeep': 'The previous turn is parked waiting for a plan review (run {taskId}) and sema could not reopen that approval card{noView}. It did NOT cancel the run — that would have discarded the plan for you. Your message was NOT sent. To keep this conversation, {keep}: the card comes back when the session resumes, if it is still waiting. Or {wayOut} if you no longer want that plan.{viaEngine}',
@@ -545,6 +566,11 @@ const EN = {
     'approval.boundGrants.denyPart.one': '1 tool entry is refused for the rest of this run',
     'approval.boundGrants.denyPart.other': '{count} tool entries are refused for the rest of this run',
     'approval.boundGrants.activates': 'Approving this activates the skill shown on the card: {allow}, and {deny}.',
+    'approval.boundGrants.allowPart.named.one': '1 tool entry it lists runs without asking once it is active ({names})',
+    'approval.boundGrants.allowPart.named.other': '{count} tool entries it lists run without asking once it is active ({names})',
+    'approval.boundGrants.denyPart.named.one': '1 tool entry is refused for the rest of this run ({names})',
+    'approval.boundGrants.denyPart.named.other': '{count} tool entries are refused for the rest of this run ({names})',
+    'approval.boundGrants.more': 'and {count} more',
     'session.fileHistoryRefusal.notYet': "Nothing was sent: file checkpointing is turned off in your settings, but this engine's capabilities have not been read yet, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. Try again in a moment; to send regardless and let file history be recorded this time, turn file checkpointing back on in your settings.",
     'session.fileHistoryRefusal.notSaid': 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can stop recording file history for a session, so sending now could record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.',
     'session.fileHistoryRefusal.unrecognized': 'Nothing was sent: file checkpointing is turned off in your settings, but this engine reported a file-history capture mode this client does not recognize, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.',
@@ -556,6 +582,12 @@ const EN = {
     'session.memorySync.parkedUnnamed.other': 'Memory sync is paused on this deployment for {count} layers: their sync cursors could not be used. {wayOut}',
     'session.memorySync.wayOut.deleteCursor': 'Syncing resumes once an operator deletes the sync cursor of each paused layer on the server; entries deleted on only one side since the last sync will come back and need to be deleted again.',
     'session.memorySync.wayOut.unrecognized': 'The deployment named a way out that this client does not recognize, so none is suggested here.',
+    'session.memorySyncTrigger.notConfigured': 'Nothing to sync: this session does not use any memory.',
+    'session.memorySyncTrigger.noSettledRun': 'Memory cannot be synced yet: no run in this session has finished with a record of which memory it reads. Run a task in this session (or let the one in progress finish), then sync again.',
+    'session.memorySyncTrigger.runUnobserved': 'Memory cannot be synced: the latest finished run in this session has no record of which memory it read, and an earlier run is never used in its place. Run another task in this session (if that run was refused, fix what refused it first), then sync again.',
+    'session.memorySyncTrigger.memoryNotMounted': 'Memory cannot be synced: memory was set up for the latest finished run in this session but did not load, so which memory this session reads is unknown. Run another task in this session (if its memory fails to load again, fix that first), then sync again.',
+    'session.memorySyncTrigger.noLeaf': 'Memory cannot be synced yet: this session has no conversation yet, so there is nothing to sync from. Run a task in it (or let the one in progress finish), then sync again.',
+    'session.memorySyncTrigger.unobtainable': 'Memory cannot be synced: which memory this session reads could not be determined. Run a task in this session (or let the one in progress finish), then sync again.',
     'session.hostSettings.memorySwitchMalformed': 'The memory setting in your settings file could not be read, so turning memory off was not applied: this request was sent with memory available. Fix the memory section (memory.enabled must be true or false) to turn it off.',
     'session.hostSettings.fileHistoryRestoreConflict': 'Nothing was sent: file checkpointing was turned off in your settings after this request was prepared, but this request also restores files from a checkpoint, and a request cannot do both. To restore the files, turn file checkpointing back on in your settings; otherwise send the request without the file restore.',
     'session.hostSettings.projectionUnchecked': 'The settings for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
@@ -565,11 +597,14 @@ const EN = {
     'session.hostSettings.layerNotLoaded.hold.unreadable': '{layer} could not be read, so the rules and hooks in that file would not apply to this request. Continue without these settings, or cancel and fix the file first.',
     'session.hostSettings.layerNotLoaded.hold.rejected': '{layer} were not loaded because a hook guarding tool use in that file is malformed, so the rules and hooks in that file would not apply to this request. Continue without these settings, or cancel and fix the file first.',
     'session.hostSettings.layerNotLoaded.sent.unreadable': '{layer} could not be read: this request was sent without the rules and hooks in that file.',
+    'session.hostSettings.layerNotLoaded.restrictions.hold': '{layer} could not be read, so the restrictions in that file (deny and ask rules) would not apply to this request. Continue without them, or cancel and fix the file first.',
+    'session.hostSettings.layerNotLoaded.restrictions.sent': '{layer} could not be read: this request was sent without the restrictions in that file (deny and ask rules).',
     'session.hostSettings.layer.policySettings': 'Managed settings',
     'session.hostSettings.layer.userSettings': 'Your user settings',
     'session.hostSettings.layer.projectSettings': 'The project settings',
     'session.hostSettings.layer.localSettings': 'The local project settings',
     'session.hostSettings.layer.flagSettings': 'The settings passed at launch',
+    'session.hostSettings.layer.foreignProjectSettings': "The project's settings for another tool",
     '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.',
@@ -603,7 +638,6 @@ const EN = {
     'rules.refusal.list.more': '{shown} and {count} more',
     'rules.refusal.reason.toolName': 'its tool name is not one this engine recognizes',
     'rules.refusal.reason.homePath': 'it uses a ~/ path this engine cannot anchor — write the path relative to the project or as an absolute path',
-    'rules.refusal.reason.neverMatches': 'this rule form cannot match as a deny or ask rule for this tool, so the engine would never apply it — to block the tool altogether, write its name alone',
     'rules.nearMiss.sentence.one': 'permissions: 1 rule names a tool by a spelling no tool of this run answers to, so it can never match — {list}',
     'rules.nearMiss.sentence.other': 'permissions: {count} rules name a tool by a spelling no tool of this run answers to, so they can never match — {list}',
     'rules.nearMiss.reason': 'write the name as "{mounted}"',
@@ -734,17 +768,6 @@ const EN = {
     'notice.capability.hands.unknownRosterUnreadable': 'whether this run has file-and-shell tools is unknown — the tool roster could not be read in the shape this reader knows',
     'notice.capability.hands.unknownMountConditionAbsent': 'whether this run has file-and-shell tools is unknown — this engine does not report which condition mounted each tool, so an empty count here would be a fact about the reader, not about the run',
     'rules.sessionPolicy.tighten.written': 'Session rules saved (version {rev}) — the record now holds everything it already had plus the entries sent here, and it applies from this session’s next tool gate onward; the step already running is not interrupted.',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.counts': "Still running, and possibly started before this session's first rule: {list}. Anything that started before that first rule keeps running without this one — to make the rule apply to it now, stop it.",
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unreadable': "This client could not read which background agents or workflows are running now. Anything that started before this session's first rule keeps running without this one — stop whatever must not keep running without it.",
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unseen': 'Work whose start has not reached this client yet may not read this rule either.',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.one': '{n} background agent',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.many': '{n} background agents',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.one': '{n} workflow',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.many': '{n} workflows',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.one': '{n} background item this client stopped tracking',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.many': '{n} background items this client stopped tracking',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.two': '{a} and {b}',
-    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.three': '{a}, {b} and {c}',
     'rules.sessionPolicy.tighten.conflict': 'Session rules were changed by someone else while this tightening was being written, twice in a row — nothing was written. Re-read the current rules and try again, or let the other writer finish first.',
     'rules.sessionPolicy.tighten.loosenForbidden': 'The engine refused this write because it would relax the session rules: at least one entry sent here widens what is allowed rather than narrowing it. Only entries that add restrictions are accepted on this path.',
     'rules.sessionPolicy.tighten.capabilityAbsent': 'This deployment does not keep per-session tool rules, so there is nothing to tighten here.',
@@ -965,6 +988,7 @@ const EN = {
     'notice.wireRefusal.hostPosture.both': "The engine refused this request before anything ran: the request asked both for the shell to inherit this machine's whole environment and for bypassPermissions, and this deployment refused at least one of them; the refusal does not say which · {notLocal}; send it again without one or both (the whole-environment setting is honored only on a single-user deployment)",
     'notice.wireRefusal.hostPosture.unattributed': "The engine refused this request before anything ran: this deployment does not accept a setting in it that only a single-user deployment may use; the engine's own message names it · {notLocal}; send it again without that setting",
     '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.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,7 +1102,7 @@ const EN = {
     '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.",
     'follow.notFollowed.reason.exhaustedConnectionLost': ": the connection dropped on the last attempt, and this client's re-attach allowance has run out.",
-    'follow.notFollowed.reason.exhaustedStreamCap': ": its event stream hit the engine's time limit on the last attempt, and this client's re-attach allowance has run out.",
+    'follow.notFollowed.reason.exhaustedStreamCap': ": the engine ended its event stream with a stream-limit notice on the last attempt, and this client's re-attach allowance has run out.",
     'follow.notFollowed.reason.exhausted': ": this client's re-attach allowance has run out.",
     'follow.notFollowed.reason.badInput': ': this client hit an internal error while re-attaching.',
     'follow.notFollowed.reason.noRunId': ': this client never learned which run it was, so there is nothing to re-attach to.',
@@ -1101,6 +1125,11 @@ const EN = {
     'approval.planReview.askAgain.notCarried': 'The user could not approve this plan: its text did not reach the approval card (it may be too long). Present a shorter plan.',
     'approval.planReview.askAgain.unknown': 'The user could not approve this plan: the approval card could not show it. Present the plan again.',
     'approval.planReview.askAgain.withNote': '{sentence} The user added: {note}',
+    'approval.planReview.decision.notSent': 'The plan_review {decision} could NOT be sent; the plan is still waiting for a decision.',
+    'approval.planReview.decision.refused': 'This {decision} was not applied: the engine refused it and changed nothing.',
+    'approval.planReview.decision.cardMissing': 'Approving a plan needs the card that showed it, and none came with this approval.',
+    'approval.planReview.decision.gateMoved': 'The plan on this card is no longer the one waiting for approval.',
+    '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',
 };