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.
TypeScript adhdagent-orchestrationai-agentscanvasclaude-codecodexcoding-agentsdeveloper-toolselectrongeminilinuxmacosmultiplexeropencodeparallel-agentsterminalterminal-emulatorterminal-multiplexertmuxworkspace-manager
feat(privacy): consent for license checks under DO_NOT_TRACK
reviewd132ff8d4bb9
diff --git a/src/main/index.ts b/src/main/index.tsindex 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.tsindex 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.tsxindex 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 itsdiff --git a/src/renderer/components/settings/sections/PrivacySection.test.tsx b/src/renderer/components/settings/sections/PrivacySection.test.tsxindex 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 = truelet root: Rootlet host: HTMLElement+/** What core answers `projectLimit.state()` with; the consent row reads `dnt` from it. */+let limitState: ProjectLimitState+let pushLimit: ((s: ProjectLimitState) => void) | nullbeforeEach(() => {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.tsxindex 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}><FieldRowlabel="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={<Switchchecked={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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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,