Skip to content

Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.

feat(privacy): consent for license checks under DO_NOT_TRACK

reviewd132ff8d4bb9
diff --git a/src/main/index.ts b/src/main/index.ts
index a49975999..08f54de26 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -375,7 +375,7 @@ import {
} from './window-state'
import { remoteCodexUsageTargets } from '../core/usage/remote-codex-usage'
import { remoteUsageTargets } from '../core/usage/remote-claude-usage'
-import { initLicense, isPremium, getStoredEntitlement } from '../core/license'
+import { initLicense, isPremium, getStoredEntitlement, setLicenseNetworkConsent } from '../core/license'
import { initProjectLimit } from '../core/project-limit'
import { readMachineHashResult } from '../core/machine-id'
import { WhisperModelStore } from '../core/speech/whisper-models'
@@ -4893,6 +4893,12 @@ app.whenReady().then(async () => {
notify: (s) => sendToMain(IPC.projectLimitChanged, s)
})
settingsStore.onChange(() => projectLimit.refresh())
+ // DO_NOT_TRACK consent for license and allowance calls (spec §7.4): Settings → Privacy, read on
+ // every gated call so revoking it applies at once. Installed BEFORE initLicense, whose launch
+ // refresh runs immediately. Only `licenseNetworkGate()` callers read it — never telemetry or the
+ // check feed. (Giving consent does not trigger a refresh: license.ts exposes none, so the next
+ // license call is the 6 h refresh, an activate or an upgrade; a claim reads the gate itself.)
+ setLicenseNetworkConsent(() => settingsStore.get().licenseNetworkConsent === true)
// A license change (activate, refresh, a lapsed token replaced) re-arms every live link the API
// refused: a link host whose 7-day entitlement expired under it stops minting until then (R41).
// It can also change Pro for the project limit, which nothing else would tell the renderer.
diff --git a/src/main/project-limit-wiring.test.ts b/src/main/project-limit-wiring.test.ts
index 073b40da2..e945a0ee5 100644
--- a/src/main/project-limit-wiring.test.ts
+++ b/src/main/project-limit-wiring.test.ts
@@ -36,6 +36,18 @@ describe('project-limit wiring (source)', () => {
expect(main).toMatch(/settingsStore\.onChange\(\(\) => projectLimit\.refresh\(\)\)/)
})
+ it('DO_NOT_TRACK consent is the Privacy setting, read live, and installed before the first license call', () => {
+ // Exactly `=== true`: a hand-edited settings.json holding "yes" or 1 is not consent. Read on every
+ // gated call (license.ts), so revoking it in Settings takes effect at once.
+ const wire = 'setLicenseNetworkConsent(() => settingsStore.get().licenseNetworkConsent === true)'
+ const at = main.indexOf(wire)
+ expect(at).toBeGreaterThan(-1)
+ // Before initLicense: its launch refresh runs immediately and must already see the consent.
+ expect(main.indexOf('initLicense(')).toBeGreaterThan(at)
+ // The Server Edition has no license layer to consent to.
+ expect(read('server/index.ts')).not.toMatch(/setLicenseNetworkConsent/)
+ })
+
it('nothing broadcasts the channel, and the Server Edition does not run the module', () => {
for (const p of ['main/index.ts', 'core/project-limit.ts', 'server/index.ts']) {
expect(read(p)).not.toMatch(/broadcast\(IPC\.projectLimitChanged/)
diff --git a/src/renderer/canvas/Canvas.tsx b/src/renderer/canvas/Canvas.tsx
index b237d7649..d66552b51 100644
--- a/src/renderer/canvas/Canvas.tsx
+++ b/src/renderer/canvas/Canvas.tsx
@@ -791,6 +791,7 @@ import {
import { scopeFromKey, usageScopeKey } from '../lib/usageScope'
import { useSystemAccount } from '../state/systemAccount'
import { useEntitlement } from '../state/entitlement'
+import { useProjectLimit } from '../state/projectLimit'
import type { SshServer } from '@shared/ssh'
import { sshHostKey } from '@shared/ssh'
import type {
@@ -3293,6 +3294,10 @@ export function Canvas() {
// persists the conversion, so the next load is a no-op.
const projects = ws.projects.map(migrateProjectTags)
useProjects.getState().hydrate({ ...ws, projects })
+ // The free-project limit state, read only now: core records the first-launch open count on
+ // the first read it answers with the workspace index loaded, which this load has guaranteed.
+ // Never rejects (a failed read stays dormant), and nothing here waits on it.
+ void useProjectLimit.getState().hydrate()
// Drop status entries whose node is in no project (past a grace window) — the table is
// persisted and otherwise grows forever. `orphanStatusIds` refuses to judge an incomplete
// load (no projects, or an unreadable one), so a bad index read never costs a live node its
diff --git a/src/renderer/components/settings/sections/PrivacySection.test.tsx b/src/renderer/components/settings/sections/PrivacySection.test.tsx
index de6c75331..ac6963333 100644
--- a/src/renderer/components/settings/sections/PrivacySection.test.tsx
+++ b/src/renderer/components/settings/sections/PrivacySection.test.tsx
@@ -6,14 +6,32 @@
import { act } from 'react'
import { createRoot, type Root } from 'react-dom/client'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { INACTIVE_PROJECT_LIMIT, type ProjectLimitState } from '@shared/project-limit'
;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
let root: Root
let host: HTMLElement
+/** What core answers `projectLimit.state()` with; the consent row reads `dnt` from it. */
+let limitState: ProjectLimitState
+let pushLimit: ((s: ProjectLimitState) => void) | null
beforeEach(() => {
vi.resetModules()
+ limitState = INACTIVE_PROJECT_LIMIT
+ pushLimit = null
+ // The project-limit store subscribes to `projectLimit.onChange` at IMPORT time, so the bridge has
+ // to exist before the module graph does (the same shape as LicenseSection.test.tsx).
+ ;(window as unknown as { nodeTerminal: unknown }).nodeTerminal = {
+ projectLimit: {
+ state: async () => limitState,
+ claim: vi.fn(),
+ onChange: (listener: (s: ProjectLimitState) => void) => {
+ pushLimit = listener
+ return () => {}
+ }
+ }
+ }
host = document.createElement('div')
document.body.appendChild(host)
root = createRoot(host)
@@ -22,14 +40,28 @@ beforeEach(() => {
afterEach(() => {
act(() => root.unmount())
host.remove()
+ delete (window as unknown as { nodeTerminal?: unknown }).nodeTerminal
})
+/** Mount the section after the store has read core's state, the way the app's boot effect does. */
async function renderSection(): Promise<string> {
+ const { useProjectLimit } = await import('../../../state/projectLimit')
const { PrivacySection } = await import('./PrivacySection')
+ await act(async () => {
+ await useProjectLimit.getState().hydrate()
+ })
act(() => root.render(<PrivacySection isActive />))
return host.textContent ?? ''
}
+const CONSENT_LABEL = 'Allow license checks while DO_NOT_TRACK is set'
+const CONSENT_DESCRIPTION =
+ 'Lets nodeterm contact api.nodeterm.dev for Pro and your free-project allowance only. Telemetry and the announcement feed stay off.'
+
+function consentSwitch(): HTMLButtonElement | null {
+ return host.querySelector(`button[role="switch"][aria-label="${CONSENT_LABEL}"]`)
+}
+
describe('Privacy → telemetry row', () => {
it('names the open-project count in its label', async () => {
expect(await renderSection()).toContain('Send anonymous usage data (version/OS, open-project count)')
@@ -40,4 +72,58 @@ describe('Privacy → telemetry row', () => {
'No personal data; client IP is never stored. Used to see which versions are in use and how many projects people keep open (a number only — never names, paths or hosts). A lighter anonymous install count runs regardless; fully disable with the DO_NOT_TRACK environment variable.'
)
})
+
+ it('says a one-way hash of the hardware id is used if the free-project limit is reached', async () => {
+ // Spec §6: the machine hash is a new stable identifier, so the privacy copy names it — appended
+ // to the same description, after the DO_NOT_TRACK sentence.
+ expect(await renderSection()).toContain(
+ 'fully disable with the DO_NOT_TRACK environment variable. If you reach the free-project limit, nodeterm checks your allowance with a one-way hash of this computer\'s hardware id, so the allowance stays with this machine.'
+ )
+ })
+})
+
+describe('Privacy → license checks under DO_NOT_TRACK', () => {
+ it('is absent when DO_NOT_TRACK is not set — there is nothing to consent to', async () => {
+ const text = await renderSection()
+ expect(text).not.toContain(CONSENT_LABEL)
+ expect(consentSwitch()).toBeNull()
+ })
+
+ it('is shown, with its scope spelled out, when core reports DO_NOT_TRACK', async () => {
+ limitState = { ...INACTIVE_PROJECT_LIMIT, dnt: true }
+ const text = await renderSection()
+ expect(text).toContain(CONSENT_LABEL)
+ expect(text).toContain(CONSENT_DESCRIPTION)
+ // Off by default: no consent until the user gives it.
+ expect(consentSwitch()?.getAttribute('aria-checked')).toBe('false')
+ })
+
+ it('follows a pushed state change without a remount', async () => {
+ await renderSection()
+ expect(consentSwitch()).toBeNull()
+ act(() => pushLimit!({ ...INACTIVE_PROJECT_LIMIT, dnt: true }))
+ expect(consentSwitch()).not.toBeNull()
+ })
+
+ it('toggling it on writes licenseNetworkConsent: true', async () => {
+ limitState = { ...INACTIVE_PROJECT_LIMIT, dnt: true }
+ const { useSettings } = await import('../../../state/settings')
+ const update = vi.fn()
+ useSettings.setState({ update })
+ await renderSection()
+ act(() => consentSwitch()!.click())
+ expect(update).toHaveBeenCalledTimes(1)
+ expect(update).toHaveBeenCalledWith({ licenseNetworkConsent: true })
+ })
+
+ it('reflects a consent already given, and toggling it off revokes it', async () => {
+ limitState = { ...INACTIVE_PROJECT_LIMIT, dnt: true }
+ const { useSettings } = await import('../../../state/settings')
+ const update = vi.fn()
+ useSettings.setState({ settings: { ...useSettings.getState().settings, licenseNetworkConsent: true }, update })
+ await renderSection()
+ expect(consentSwitch()?.getAttribute('aria-checked')).toBe('true')
+ act(() => consentSwitch()!.click())
+ expect(update).toHaveBeenCalledWith({ licenseNetworkConsent: false })
+ })
})
diff --git a/src/renderer/components/settings/sections/PrivacySection.tsx b/src/renderer/components/settings/sections/PrivacySection.tsx
index 066158f27..070c9c92f 100644
--- a/src/renderer/components/settings/sections/PrivacySection.tsx
+++ b/src/renderer/components/settings/sections/PrivacySection.tsx
@@ -1,4 +1,5 @@
import { useSettings } from '../../../state/settings'
+import { useProjectLimit } from '../../../state/projectLimit'
import { SettingsSection } from '../SettingsSection'
import { SearchableRow } from '../SearchableRow'
import { FieldRow } from '../FieldRow'
@@ -8,19 +9,30 @@ const ROWS = {
telemetry: {
title: 'Send anonymous usage data',
keywords: ['privacy', 'telemetry', 'usage', 'analytics', 'data']
+ },
+ licenseConsent: {
+ title: 'Allow license checks while DO_NOT_TRACK is set',
+ keywords: ['privacy', 'license', 'pro', 'do not track', 'dnt', 'consent', 'network', 'allowance', 'projects']
}
}
-const ENTRIES = Object.values(ROWS)
+// The consent row exists only while DO_NOT_TRACK is set, and so does its search entry: a query for
+// "license" must not open this section onto a row that is not there.
+const ENTRIES = [ROWS.telemetry]
+const DNT_ENTRIES = [ROWS.telemetry, ROWS.licenseConsent]
export function PrivacySection({ isActive }: { isActive: boolean }): React.JSX.Element {
const telemetryEnabled = useSettings((s) => s.settings.telemetryEnabled)
+ const licenseNetworkConsent = useSettings((s) => s.settings.licenseNetworkConsent)
const update = useSettings((s) => s.update)
+ // Core's DO_NOT_TRACK fact (spec §7.4). Never true on the Server Edition, whose stub answers the
+ // inactive state: that shell has no license layer to consent to.
+ const dnt = useProjectLimit((s) => s.state.dnt)
return (
- <SettingsSection id="privacy" title="Privacy" isActive={isActive} searchEntries={ENTRIES}>
+ <SettingsSection id="privacy" title="Privacy" isActive={isActive} searchEntries={dnt ? DNT_ENTRIES : ENTRIES}>
<SearchableRow {...ROWS.telemetry}>
<FieldRow
label="Send anonymous usage data (version/OS, open-project count)"
- description="No personal data; client IP is never stored. Used to see which versions are in use and how many projects people keep open (a number only — never names, paths or hosts). A lighter anonymous install count runs regardless; fully disable with the DO_NOT_TRACK environment variable."
+ description="No personal data; client IP is never stored. Used to see which versions are in use and how many projects people keep open (a number only — never names, paths or hosts). A lighter anonymous install count runs regardless; fully disable with the DO_NOT_TRACK environment variable. If you reach the free-project limit, nodeterm checks your allowance with a one-way hash of this computer's hardware id, so the allowance stays with this machine."
control={
<Switch
checked={telemetryEnabled}
@@ -30,6 +42,21 @@ export function PrivacySection({ isActive }: { isActive: boolean }): React.JSX.E
}
/>
</SearchableRow>
+ {dnt ? (
+ <SearchableRow {...ROWS.licenseConsent}>
+ <FieldRow
+ label="Allow license checks while DO_NOT_TRACK is set"
+ description="Lets nodeterm contact api.nodeterm.dev for Pro and your free-project allowance only. Telemetry and the announcement feed stay off."
+ control={
+ <Switch
+ checked={licenseNetworkConsent === true}
+ onChange={(v) => update({ licenseNetworkConsent: v })}
+ ariaLabel="Allow license checks while DO_NOT_TRACK is set"
+ />
+ }
+ />
+ </SearchableRow>
+ ) : null}
</SettingsSection>
)
}
diff --git a/src/renderer/state/projectLimit.test.ts b/src/renderer/state/projectLimit.test.ts
new file mode 100644
index 000000000..02977354b
--- /dev/null
+++ b/src/renderer/state/projectLimit.test.ts
@@ -0,0 +1,111 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import fs from 'fs'
+import path from 'path'
+import type { NodeTerminalApi } from '@shared/types'
+import { INACTIVE_PROJECT_LIMIT, type ProjectLimitState } from '@shared/project-limit'
+
+// The renderer's copy of core's project-limit state (src/core/project-limit.ts). Two things matter
+// here: it follows core — the hydrate read AND every `projectLimit:changed` push replace it — and a
+// failed read leaves it DORMANT. Inactive is the state in which every open behaves exactly as it did
+// before the limit existed (spec §2), so it is the only safe thing to hold when core cannot be asked.
+
+const stateCall = vi.fn<() => Promise<ProjectLimitState>>()
+let pushed: ((s: ProjectLimitState) => void) | null = null
+
+const ACTIVE: ProjectLimitState = { active: true, pro: false, free: 5, allowance: null, dnt: false }
+const DNT: ProjectLimitState = { ...INACTIVE_PROJECT_LIMIT, dnt: true }
+
+type Store = typeof import('./projectLimit').useProjectLimit
+
+/** Fresh module graph per test: the store subscribes to `projectLimit.onChange` at import time
+ * (the entitlement store's shape), so the bridge has to exist first. */
+async function freshStore(): Promise<Store> {
+ vi.resetModules()
+ pushed = null
+ vi.stubGlobal('window', {
+ nodeTerminal: {
+ projectLimit: {
+ state: () => stateCall(),
+ claim: vi.fn(),
+ onChange: (listener: (s: ProjectLimitState) => void) => {
+ pushed = listener
+ return () => {}
+ }
+ }
+ } as unknown as NodeTerminalApi
+ })
+ const { useProjectLimit } = await import('./projectLimit')
+ return useProjectLimit
+}
+
+beforeEach(() => {
+ stateCall.mockReset()
+})
+
+afterEach(() => {
+ vi.unstubAllGlobals()
+})
+
+describe('project-limit store', () => {
+ it('starts dormant, before anything has been read', async () => {
+ const useProjectLimit = await freshStore()
+ expect(useProjectLimit.getState().state).toEqual(INACTIVE_PROJECT_LIMIT)
+ })
+
+ it('hydrate installs the state core answers', async () => {
+ const useProjectLimit = await freshStore()
+ stateCall.mockResolvedValue(ACTIVE)
+ await useProjectLimit.getState().hydrate()
+ expect(stateCall).toHaveBeenCalledTimes(1)
+ expect(useProjectLimit.getState().state).toEqual(ACTIVE)
+ })
+
+ it('a push from core replaces the state wholesale', async () => {
+ const useProjectLimit = await freshStore()
+ stateCall.mockResolvedValue(ACTIVE)
+ await useProjectLimit.getState().hydrate()
+ // Subscribed at import, before any hydrate: a push that races the first read is not lost.
+ expect(pushed).not.toBeNull()
+ pushed!(DNT)
+ // Replaced, not merged: `active: true` from the read must not survive a push that says false.
+ expect(useProjectLimit.getState().state).toEqual(DNT)
+ })
+
+ it('a rejected read leaves the state dormant, and hydrate itself does not reject', async () => {
+ const useProjectLimit = await freshStore()
+ stateCall.mockRejectedValue(new Error('No handler registered for projectLimit:state'))
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ await expect(useProjectLimit.getState().hydrate()).resolves.toBeUndefined()
+ expect(useProjectLimit.getState().state).toEqual(INACTIVE_PROJECT_LIMIT)
+ warn.mockRestore()
+ })
+
+ it('a rejected read keeps a state core already pushed, rather than resetting it', async () => {
+ const useProjectLimit = await freshStore()
+ pushed!(DNT)
+ stateCall.mockRejectedValue(new Error('gone'))
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ await useProjectLimit.getState().hydrate()
+ expect(useProjectLimit.getState().state).toEqual(DNT)
+ warn.mockRestore()
+ })
+})
+
+describe('project-limit store wiring (source)', () => {
+ it('the boot effect reads the state AFTER the projects store is hydrated from the workspace', () => {
+ // Core records the first-launch open count on the first `state()` it answers once the workspace
+ // index is loaded (`openProjectCount()` is undefined before that, and nothing is recorded). Read
+ // after the load has resolved, the boot read is the one that records it — not a later read that
+ // may come only after the user has opened more projects.
+ const canvas = fs
+ .readFileSync(path.join(__dirname, '..', 'canvas', 'Canvas.tsx'), 'utf8')
+ .replace(/\r\n/g, '\n')
+ const projects = canvas.indexOf('useProjects.getState().hydrate({ ...ws, projects })')
+ const limit = canvas.indexOf('void useProjectLimit.getState().hydrate()')
+ expect(projects).toBeGreaterThan(-1)
+ expect(limit).toBeGreaterThan(projects)
+ // …and inside the same `workspace.load().then` callback, not some later effect.
+ const between = canvas.slice(projects, limit)
+ expect(between).not.toMatch(/\n {2}\}, \[/)
+ })
+})
diff --git a/src/renderer/state/projectLimit.ts b/src/renderer/state/projectLimit.ts
new file mode 100644
index 000000000..8618862a7
--- /dev/null
+++ b/src/renderer/state/projectLimit.ts
@@ -0,0 +1,37 @@
+import { create } from 'zustand'
+import { INACTIVE_PROJECT_LIMIT, type ProjectLimitState } from '@shared/project-limit'
+
+/**
+ * The renderer's copy of the free-tier open-project limit state (core/project-limit.ts computes it;
+ * docs/superpowers/specs/2026-10-29-free-tier-project-limit-design.md). Core is the authority: this
+ * store only mirrors it — the boot read (`hydrate`) and every `projectLimit:changed` push replace
+ * `state` wholesale. It starts, and stays on any failed read, at `INACTIVE_PROJECT_LIMIT`: the
+ * dormant answer, under which every open behaves exactly as before the limit existed.
+ *
+ * Desktop: the preload's `projectLimit`. Server Edition: the bridge stub answers inactive forever.
+ * A relay tab keeps the LOCAL preload's api (the allowance is this machine's, never the host's).
+ */
+interface ProjectLimitStore {
+ state: ProjectLimitState
+ /** Read core's current state. Never rejects: a failed read keeps whatever is held (inactive until
+ * core has said otherwise). Called from the boot effect AFTER the projects store is hydrated —
+ * core records the first-launch open count on the first read it answers with the index loaded. */
+ hydrate(): Promise<void>
+}
+
+export const useProjectLimit = create<ProjectLimitStore>((set) => {
+ // Live updates from core: a server word, a license or settings change, time passing the deadline.
+ // Subscribed at creation (the entitlement store's shape), so a push that lands before the first
+ // read is not lost.
+ window.nodeTerminal.projectLimit.onChange((state) => set({ state }))
+ return {
+ state: INACTIVE_PROJECT_LIMIT,
+ async hydrate() {
+ try {
+ set({ state: await window.nodeTerminal.projectLimit.state() })
+ } catch (err) {
+ console.warn('[project-limit] state read failed', err instanceof Error ? err.message : String(err))
+ }
+ }
+ }
+})
diff --git a/src/shared/settings-verb.test.ts b/src/shared/settings-verb.test.ts
index b3b589834..250d32695 100644
--- a/src/shared/settings-verb.test.ts
+++ b/src/shared/settings-verb.test.ts
@@ -71,6 +71,7 @@ describe('the allowlist is the gate, and the forbidden set outranks it', () => {
'hookIdentityStrict',
'hookReplyApprovals',
'keybindings',
+ 'licenseNetworkConsent',
'modelGateway',
'modelGatewayDefaultModel',
'phoneAccessEnabled',
@@ -89,6 +90,20 @@ describe('the allowlist is the gate, and the forbidden set outranks it', () => {
for (const key of SETTINGS_VERB_KEY_LIST) expect(SETTINGS_VERB_FORBIDDEN_PATTERN.test(key), key).toBe(false)
})
+ it('an agent can never grant network consent under DO_NOT_TRACK on the user\'s behalf', () => {
+ // `licenseNetworkConsent` lets license and allowance calls reach api.nodeterm.dev while
+ // DO_NOT_TRACK is set (spec §7.4). It is a privacy decision the user makes in Settings → Privacy;
+ // a CLI that could set it would turn the user's DO_NOT_TRACK into a suggestion. Named in the set
+ // AND caught by the `consent` name class, so neither fence alone carries it.
+ expect((SETTINGS_VERB_FORBIDDEN as ReadonlySet<string>).has('licenseNetworkConsent')).toBe(true)
+ expect(SETTINGS_VERB_FORBIDDEN_PATTERN.test('licenseNetworkConsent')).toBe(true)
+ for (const args of [{ get: 'licenseNetworkConsent' }, { set: 'licenseNetworkConsent', value: 'true' }]) {
+ expect(parseSettingsRequest(args)).toEqual({
+ error: expect.stringContaining('settings-key-forbidden: "licenseNetworkConsent"')
+ })
+ }
+ })
+
it('the name pattern catches forbidden classes nobody has named yet', () => {
for (const future of ['modelGatewayApiKey', 'relayToken', 'agentBrowserPartition', 'skipConfirm', 'permissionModeOverride']) {
expect(SETTINGS_VERB_FORBIDDEN_PATTERN.test(future), future).toBe(true)
diff --git a/src/shared/settings-verb.ts b/src/shared/settings-verb.ts
index 7fe3112df..8a4ad8c18 100644
--- a/src/shared/settings-verb.ts
+++ b/src/shared/settings-verb.ts
@@ -156,6 +156,10 @@ export const SETTINGS_VERB_FORBIDDEN = new Set<keyof Settings | keyof Project>([
'agentMessagingDefault',
// Telemetry.
'telemetryEnabled',
+ // Consent to license and allowance calls while DO_NOT_TRACK is set (spec §7.4). A privacy decision:
+ // an agent that could grant it would turn the user's DO_NOT_TRACK into a suggestion. The `consent`
+ // name class below catches it too; it is named here so the snapshot test pins it either way.
+ 'licenseNetworkConsent',
// Keybindings and the terminal-first shortcut policy.
'keybindings',
'terminalShortcutPolicy',
diff --git a/src/shared/types.ts b/src/shared/types.ts
index 82bcd657c..0cb825d71 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -2360,6 +2360,14 @@ export interface Settings {
* (or hard-disable with DO_NOT_TRACK / NODETERM_TELEMETRY_DISABLED). Note: a lighter anonymous
* install count also rides the /v1/check call and is NOT gated on this toggle — see core/check.ts. */
telemetryEnabled: boolean
+ /** The user's consent to license and free-project-allowance calls to api.nodeterm.dev while
+ * DO_NOT_TRACK / NODETERM_TELEMETRY_DISABLED is set (spec §7.4). Default off: under DNT nothing
+ * license-related leaves the machine until the user says so. Covers ONLY the calls behind
+ * `licenseNetworkGate()` (core/license.ts) — never telemetry or the check feed, which stay off
+ * under DNT whatever this says. Read as `=== true` (main installs it via
+ * `setLicenseNetworkConsent`), so a hand-edited non-boolean is no consent. Shown and revocable in
+ * Settings → Privacy only while DNT is set. Never settable by an agent (SETTINGS_VERB_FORBIDDEN). */
+ licenseNetworkConsent: boolean
/** Debug log panel (issue #78): captures the app's own console into an in-memory, redacted
* ring and unlocks the log viewer. Default off — a debugging tool, not a daily surface.
* Toggle in Settings → Application → Debug. */
@@ -2619,6 +2627,8 @@ export const DEFAULT_SETTINGS: Settings = {
// Opt-out (default on). Existing users pick this up on hydrate ONLY if their settings.json has
// no telemetryEnabled key yet; anyone who already saved settings keeps their stored value.
telemetryEnabled: true,
+ // Off: under DO_NOT_TRACK no license call runs until the user consents in Settings → Privacy.
+ licenseNetworkConsent: false,
debugLogPanel: false,
phoneAccessEnabled: true,
mobilePushEnabled: true,