xTechNotes - Technical Computing Programming Notes

Prompt Gatekeeper and Model Recommender - For Switching Models in ClaudeCode

2026-09-26T08:04:49.635-07:00

**Location:** `<USER>\.claude\prompt_gatekeeper_model_switcher.md`

**Created:** 2026-09-26

**Revised:** 2026-09-26 (v2 -- integrity review and rebuild; v3 -- state moved to Stop hook, Option D; v4 -- [check] soft-check mode; v5 -- second integrity review, hooks aligned, doc swept)

**Status:** Implemented and ENABLED (both hooks)

Note: Section 5 examples show the v2 layout in which the state block was printed on

prompt submit. Section 13 supersedes that: state is now shown at end of turn by

`state_monitor.py`, and the submit-time block carries only the model recommendation.

Sections 0 to 4 and 6 to 10 were brought up to date in v5 (Section 15).

---

## Table of Contents

0. [PRIME DIRECTIVE](#s0)

1. [Intent](#s1)

2. [Design](#s2)

3. [Files and Components](#s3)

4. [Implementation](#s4)

5. [Usage and Examples](#s5)

6. [Enable / Disable](#s6)

7. [Extending the Rules](#s7)

8. [Limitations](#s8)

9. [Convention Scope -- Global](#s9)

10. [Verification -- the state-file design](#s10)

11. [Revision history -- v1 integrity review](#s11)

12. [Future direction -- LLM-based assessment (planning)](#s12)

13. [v3 -- State split to end of turn, Option D implemented](#s13)

14. [v4 -- [check] soft-check mode](#s14)

15. [v5 -- second integrity review](#s15)

A. [Appendix A -- Full source of the live files](#appA)

---

## 0. PRIME DIRECTIVE

[Back to TOC](#toc)

**The gatekeeper hooks (`gatekeeper.py` and `state_monitor.py`) NEVER run git -- not

directly, not indirectly.**

Concretely:

- They spawn no processes of any kind. No `subprocess`, no `os.system`, no `os.popen`,

no `pty`, no `multiprocessing`, no shelling out.

- Their only inputs are the JSON that Claude Code pipes to stdin and one file,

`task_state.json`.

- Their only output is one JSON object on stdout.

- A runtime self-check (`check_prime_directive()`) confirms that no process-spawning

module has been loaded. If one ever is, the violation is printed in the user-visible

message and in Claude's context so it cannot go unnoticed.

- Any future extension (including the LLM-based assessment in Section 12) must honour

this. An HTTP call to a model API is permitted; spawning a CLI is not.

Rationale: a hook fires on every prompt in every project. Running git from it means an

uncontrolled process touching every repository the user opens, with no audit trail and no

way for the user to see it happen. Clean-state assessment is a semantic judgement and is

made from the state file alone (see Section 10).

Scope: the directive binds the two hooks built here. The Siemens-mandated code-scan

`PreToolUse` hook in the same `settings.json` fetches its tool with `uvx --from git+https`;

that is outside this design and is not governed by it.

---

## 1. Intent

[Back to TOC](#toc)

When working in Claude Code Terminal across long sessions, two decisions recur constantly:

1. **Is it safe to switch model or effort level?** Switching mid-task risks losing context

coherence or leaving work in an inconsistent state. The user needs to know whether the

current task is genuinely complete before changing model or effort.

2. **Which model should I use for this prompt?** Claude Code supports four models with

very different cost and capability profiles. Choosing the wrong one either wastes money

(using Fable for a simple edit) or produces poor results (using Haiku for complex

ontology work). The user should not have to remember the tradeoffs for every prompt.

The Prompt Gatekeeper is a lightweight hook that fires on every prompt submission and

answers both questions automatically:

- It reports whether the session is in a clean state (task complete) or mid-task.

- It analyses the prompt text and recommends the most appropriate model.

- It optionally suggests an effort level.

- It warns explicitly if it is NOT safe to switch, or if the recommended model is

expensive (Fable).

The gatekeeper is ADVISORY only. It never switches the model or effort automatically.

The user reads the recommendation and acts on it (or ignores it).

Note on timing: the hook fires after the prompt is submitted, so the current prompt is

already being handled by the current model. Every recommendation therefore applies to the

NEXT prompt, not this one.

---

## 2. Design

[Back to TOC](#toc)

### 2.1 Hook mechanism

Claude Code supports a `UserPromptSubmit` hook: a shell command that fires every time

the user submits a prompt, before Claude processes it. The hook receives a JSON object on

stdin (fields include `user_prompt`, `cwd`, `session_id`, `transcript_path`) and returns

a JSON object on stdout with two channels:

| JSON field | Who sees it |

|------------|-------------|

| `systemMessage` | The USER, in the terminal |

| `hookSpecificOutput.additionalContext` | CLAUDE, injected into its context |

Stderr from a hook that exits 0 goes to the debug log only. It is never shown to the

user, so the gatekeeper does not write to stderr at all.

The hook cannot automatically switch the model or effort. It could block the prompt

(exit code 2) but the gatekeeper never does.

### 2.2 Clean state assessment -- single signal, state file only

The sole clean-state signal is `task_state.json` at `<USER>\.claude\hooks\`. Claude

writes this file at the start and end of every substantial task, per the global

CLAUDE.md convention. Fields:

| Field | Purpose |

|-------|---------|

| `status` | `"in_progress"` or `"clean"` |

| `task` | Short name of the current task |

| `detail` | Optional extra description |

| `project` | Short project label (e.g. "BFSI") -- disambiguates across projects |

| `cwd` | Working directory at time of writing -- for context |

| `updated` | ISO timestamp in LOCAL time -- informational; age is taken from file mtime (Section 13) |

If `status` is `"in_progress"` and the file was last written more than 24 hours ago,

both hooks raise a stale warning: the file may have been left dirty and forgotten. The

threshold is `STALE_HOURS` in each script. Age is measured from the file's modification

time, so it works even when `updated` is empty; the `updated` field is a fallback only.

If the file is missing or unreadable, the state is reported as clean with an explicit

note saying so. If `status` holds any value other than `clean` or `in_progress` (a typo

such as `in-progress`), both hooks report the value and assume clean. There is no

fallback signal (see PRIME DIRECTIVE).

"Task complete" is a semantic judgement. Uncommitted files in a repository are the

normal resting state of a working directory and say nothing about whether a task is

finished, which is why v1's git corroboration was removed (Section 11).

### 2.3 Model recommendation -- word-boundary keyword matching

The gatekeeper scans the lowercased prompt for keywords associated with each model.

Rules are evaluated top-to-bottom; the first match wins. If nothing matches, Sonnet is

the default.

Keywords match on word boundaries only: `ttl` matches "ttl" and "ttl-file" but not

"settle"; `no` does not match "know"; `ok` does not match "look".

The Haiku rule additionally applies only to prompts of eight words or fewer. A long

prompt that happens to contain "ok" or "yes" is not a confirmation.

| Model | Trigger keywords (examples) | Use when |

|-------|-----------------------------|----------|

| Opus 5.5 | ttl, sparql, ontology, implement, review all, graphmart | Complex reasoning, code generation, deep review |

| Sonnet 5 | explain, update, edit, what is, clarify | Edits, explanations, medium tasks (default) |

| Haiku 4.5 | yes, ok, go ahead, proceed, thanks (short prompts only) | Confirmations, trivial follow-ups |

| Fable 5.1 | full build, end to end, autonomous, run everything | Long-horizon multi-step autonomous tasks ONLY |

Fable is placed last and carries an explicit cost warning. Anthropic's guidance: use

Fable for demanding reasoning and long-horizon agentic work, or when Opus at higher

effort still falls short. Price figures in the script header are as recorded in Sep 2026

and unverified; check the current price list before relying on them.

### 2.4 Effort recommendation

Separately from the model, the gatekeeper scans for effort-signal keywords (also on

word boundaries):

- High effort: "review all", "self-review", "full review", "check everything", "audit",

"validate all", "integrity check", "deep review"

- Low effort: "quick", "briefly", "one line", "just check", "in short"

- Otherwise: no effort recommendation (leave current setting)

The lists above are the live `EFFORT_HIGH_KEYWORDS` and `EFFORT_LOW_KEYWORDS` as of v5.

### 2.5 Output

On every prompt the gatekeeper returns one JSON object containing a plain-ASCII summary

block for the user (`systemMessage`) and a one-line note for Claude

(`additionalContext`). No colour codes are used because `systemMessage` is rendered by

Claude Code, not by a raw terminal.

---

## 3. Files and Components

[Back to TOC](#toc)

`<USER>` = `C:\Users\<username>` on this machine. Substitute your own Windows user path

when replicating on another machine.

### Files created (full paths)

| Full path | Purpose |

|-----------|---------|

| `<USER>\.claude\hooks\gatekeeper.py` | UserPromptSubmit hook -- model recommendation, Option D instruction, `[check]` mode (Section 14) |

| `<USER>\.claude\hooks\state_monitor.py` | Stop hook -- shows state at end of each turn (Section 13) |

| `<USER>\.claude\hooks\task_state.json` | Live clean-state signal (read by hook, written by Claude) |

| `<USER>\.claude\prompt_gatekeeper_model_switcher.md` | This document |

### Files modified (full paths)

| Full path | Change |

|-----------|--------|

| `<USER>\.claude\settings.json` | Added `UserPromptSubmit` hook block (gatekeeper.py) and `Stop` hook block (state_monitor.py) |

| `<USER>\.claude\CLAUDE.md` | Added "Task State Convention" section -- the global instruction mechanism, including the `[check]` rule |

### Note on global vs. project-local instructions

| Mechanism | Scope | Used for |

|-----------|-------|----------|

| `<USER>\.claude\CLAUDE.md` | Global (all projects) | Standing behavioural rules, conventions |

| `<USER>\.claude\settings.json` | Global (all projects) | Hook registration, model defaults, env vars |

| `<project>\memory\*.md` | Project-local | Project-specific context and decisions |

The task state convention and the PRIME DIRECTIVE both live in the global `CLAUDE.md`

because the hooks are global. No project memory notes are used: auto-memory is keyed to

the directory a session starts from, so anything stored there would be invisible from

other projects. Two BFSI-scoped notes that existed briefly on 2026-09-26 were removed for

that reason; their content is in `CLAUDE.md` and Sections 12 to 15 here.

---

## 4. Implementation

[Back to TOC](#toc)

The scripts are not reproduced in this section. v1 embedded a copy here and the copy

drifted from the live file within a day (Section 11). The live files are the source of

truth:

```

<USER>\.claude\hooks\gatekeeper.py

<USER>\.claude\hooks\state_monitor.py

```

Since v5, Appendix A holds a full copy of both scripts, `task_state.json` and the two

`settings.json` hook blocks for copy-and-paste. Rule: whenever either script is edited,

re-paste it into Appendix A in the same session, then `py_compile` the live file.

To replicate on another machine:

### Step 1 -- Create the hooks directory

```

mkdir <USER>\.claude\hooks

```

### Step 2 -- Create `task_state.json`

```json

{

"status": "clean",

"task": "",

"detail": "",

"project": "",

"cwd": "",

"updated": "2026-09-26T00:00:00"

}

```

### Step 3 -- Copy `gatekeeper.py` and `state_monitor.py`

Copy both live files to `<USER>\.claude\hooks\`. Then confirm they compile and honour

the PRIME DIRECTIVE:

```

C:\miniforge3\python -m py_compile gatekeeper.py state_monitor.py

```

and confirm that a source search for `subprocess`, `os.system`, `os.popen` or `git`

finds only the docstrings and the `FORBIDDEN_MODULES` tuples.

### Step 4 -- Register both hooks in `settings.json`

Add the `UserPromptSubmit` and `Stop` blocks inside the existing `"hooks"` object:

```json

"UserPromptSubmit": [

{

"hooks": [

{

"type": "command",

"command": "/c/miniforge3/python /c/Users/<username>/.claude/hooks/gatekeeper.py",

"statusMessage": "Gatekeeper assessing prompt..."

}

]

}

"Stop": [

{

"hooks": [

{

"type": "command",

"command": "/c/miniforge3/python /c/Users/<username>/.claude/hooks/state_monitor.py",

"timeout": 5

}

]

}

```

The Python path uses POSIX style (`/c/miniforge3/python`) because Claude Code runs hook

commands through bash on Windows.

### Step 5 -- Add the Task State Convention to the global `CLAUDE.md`

Paste the "Task State Convention (Gatekeeper Hooks)" section, reproduced in full in

Appendix A.5, into the target machine's `<USER>\.claude\CLAUDE.md`. Without it, Claude

will not maintain `task_state.json` and the state signal is dead.

### Step 6 -- Smoke test

```

printf '{"user_prompt":"review all the ttl files"}' | /c/miniforge3/python /c/Users/<username>/.claude/hooks/gatekeeper.py

```

Expected: one JSON line with `systemMessage` and `hookSpecificOutput`, recommending

Opus 5.5 with effort high, exit code 0.

```

printf '{}' | /c/miniforge3/python /c/Users/<username>/.claude/hooks/state_monitor.py

```

Expected: one JSON line with a `systemMessage` starting `STATE [CLEAN]`, exit code 0.

---

## 5. Usage and Examples

[Back to TOC](#toc)

### What you see on every prompt

Claude Code renders the `systemMessage` block in the terminal. Glance at it and act or

ignore it.

**Example 1 -- Clean state, Opus recommended:**

```

GATEKEEPER

State : [CLEAN] task_state.json: clean

Model : /model Opus 5.5 (trigger: 'sparql')

Use for: complex reasoning, TTL/SPARQL authoring, ontology work, deep reviews

```

Your prompt was: *"Write a SPARQL query to find all AML alerts above risk 0.7"*

Action: type `/model Opus 5.5` before your next prompt if you are not already on Opus.

**Example 2 -- Mid-task, Sonnet recommended:**

```

GATEKEEPER

State : [DIRTY] task in progress: 'Writing bfsi-case.ttl' [BFSI] -- Phase P1

Model : /model Sonnet 5 (trigger: 'explain')

Use for: edits, explanations, updates, medium-complexity tasks

! [DIRTY] task in progress -- hold off switching model/effort

```

Action: do NOT switch until the TTL task is complete.

**Example 3 -- Clean state, effort recommended:**

```

GATEKEEPER

State : [CLEAN] task_state.json: clean

Model : /model Opus 5.5 (trigger: 'ttl')

Use for: complex reasoning, TTL/SPARQL authoring, ontology work, deep reviews

Effort : consider /effort high

```

**Example 4 -- Fable recommended (with cost warning):**

```

GATEKEEPER

State : [CLEAN] task_state.json: clean

Model : /model Fable 5.1 (trigger: 'end to end')

Use for: long-horizon multi-step autonomous tasks only -- most expensive tier

! NOTE: Fable 5.1 is the most expensive tier. Only use it if this is

truly a long-horizon autonomous task that Opus at high effort cannot handle.

```

**Example 5 -- Stale state:**

```

GATEKEEPER

State : [DIRTY] task in progress: 'Writing bfsi-case.ttl' [BFSI]

Model : /model Sonnet 5 (trigger: 'default')

Use for: edits, explanations, updates, medium-complexity tasks

! Hold off switching model/effort -- finish current task first

! State flagged in_progress 31h ago in [BFSI] -- may be stale. Clear task_state.json if task is done.

```

Action: if the task really is done, ask Claude to reset `task_state.json` to clean.

Since v3 the `State` and stale lines above are printed by the Stop hook as a `STATE`

block at the end of the previous turn (Section 13), and the submit-time block shows

only a one-line `! [DIRTY] ... hold off switching` reminder when the state is dirty.

### How Claude uses the injected context

Claude receives a short note such as:

```

[Gatekeeper] State: DIRTY (task in progress: 'Writing bfsi-case.ttl' [BFSI]) --

hold off switching model or effort until current task is complete.

Suggested model: Sonnet 5 (matched keyword 'explain'; edits, explanations,

updates, medium-complexity tasks).

```

Claude can therefore remind you if you try to switch mid-task. Since v3 the note also

carries the Option D state-maintenance instruction, and in `[check]` mode the CHECK MODE

instruction (Sections 13 and 14).

### How to update task_state.json

Claude writes this file using the Write tool at task start and end. You can also write

it manually.

**Task starting:**

```json

{

"status": "in_progress",

"task": "Writing bfsi-case.ttl",

"detail": "Phase P1 -- new shared case module",

"project": "BFSI",

"cwd": "C:\\d_drive\\workKW\\WorkClaude\\BFSI",

"updated": "2026-09-26T14:32:00"

}

```

**Task complete:**

```json

{

"status": "clean",

"task": "",

"detail": "",

"project": "",

"cwd": "",

"updated": "2026-09-26T15:10:00"

}

```

---

## 6. Enable / Disable

[Back to TOC](#toc)

Each hook is controlled by a single line near the top of its script, independently:

```python

ENABLED = True # change to False to deactivate

```

- `gatekeeper.py` -- turns off the model recommendation, the Option D instruction and

`[check]` mode.

- `state_monitor.py` -- turns off the end-of-turn STATE line.

When `ENABLED = False` the script calls `sys.exit(0)` immediately after the switch is

evaluated. There is no output and no context injection. The hook is still registered in

`settings.json` and Python is still launched on every event, so the cost is one

interpreter start-up (tens of milliseconds), not zero.

Important: a syntax error anywhere in the file defeats the switch, because Python

compiles the whole file before executing the first line. v1 was disabled and still

failed on every prompt for exactly this reason. After ANY edit, run:

```

C:\miniforge3\python -m py_compile C:\Users\<username>\.claude\hooks\gatekeeper.py C:\Users\<username>\.claude\hooks\state_monitor.py

```

You do NOT need to touch `settings.json` to toggle either hook on or off.

---

## 7. Extending the Rules

[Back to TOC](#toc)

### Adding keywords to an existing model

Find the model's tuple in `MODEL_RULES` and append to its keyword list. Multi-word

phrases are fine; matching is on word boundaries at both ends of the phrase.

### Adding a new model

Add a new tuple to `MODEL_RULES` at the appropriate priority position:

```python

(

"Label", "model-id",

"description of when to use it",

["keyword1", "keyword2"],

```

### Changing the default model

Edit `DEFAULT_MODEL_LABEL`, `DEFAULT_MODEL_ID` and `DEFAULT_MODEL_PURPOSE`.

### Changing effort keywords

Edit `EFFORT_HIGH_KEYWORDS` and `EFFORT_LOW_KEYWORDS`.

### Changing the Haiku short-prompt limit

Edit `HAIKU_MAX_WORDS`.

After any change: `py_compile`, then the smoke test in Section 4 Step 6.

---

## 8. Limitations

[Back to TOC](#toc)

| Limitation | Detail |

|------------|--------|

| Advisory only | Cannot auto-switch model or effort. User must act on the recommendation. |

| Recommendation is one prompt late | The hook fires after submission. The advice applies to the next prompt. Mitigated by `[check]` mode (Section 14), which assesses without executing. |

| Sonnet label vs. settings alias | `settings.json` maps the `sonnet` alias (`ANTHROPIC_DEFAULT_SONNET_MODEL`) to `claude-sonnet-4-6@default`, while the hook recommends `/model Sonnet 5`. Untested whether `/model Sonnet 5` resolves through the Siemens proxy. If it does not, align the env var or the rule label. |

| Unexpected status is fail-open | A `status` value that is neither `clean` nor `in_progress` is reported and treated as clean by both hooks. A typo therefore unlocks switching, but visibly. |

| Keyword matching is blunt | Word boundaries remove the worst false positives, but "what does TTL stand for?" still recommends Opus. See Section 12. |

| task_state.json requires discipline | If Claude forgets to update the file, the signal is wrong. There is deliberately no fallback (PRIME DIRECTIVE). The 24h stale warning is the only safety net. |

| One global state file | Two concurrent sessions in different projects overwrite each other's state. The `project` field makes this visible but does not prevent it. |

| No task list integration | The Claude Code in-memory task list is not accessible to an external hook process. |

| Model IDs and prices may drift | Update `MODEL_RULES` and the header manually when models change. |

| POSIX path dependency | The hook command uses `/c/miniforge3/python`. If Python moves, update `settings.json`. |

---

## 9. Convention Scope -- Global

[Back to TOC](#toc)

Both gatekeeper hooks are GLOBAL -- they fire in every Claude Code session regardless

of project. The task_state.json convention is also implemented globally to match.

The instruction for Claude to update `task_state.json` is in the **global CLAUDE.md**:

```

<USER>\.claude\CLAUDE.md (section: "Task State Convention (Gatekeeper Hooks)")

```

This file is loaded at the start of every Claude Code session in every project.

| Component | Scope | Location |

|-----------|-------|----------|

| `gatekeeper.py` hook (UserPromptSubmit) | Global (all projects) | `<USER>\.claude\hooks\gatekeeper.py` |

| `state_monitor.py` hook (Stop) | Global (all projects) | `<USER>\.claude\hooks\state_monitor.py` |

| `task_state.json` | Global (shared across all projects) | `<USER>\.claude\hooks\task_state.json` |

| Hook registration | Global (all projects) | `<USER>\.claude\settings.json` |

| Task state convention instruction | Global (all projects) | `<USER>\.claude\CLAUDE.md` |

| This documentation | Global | `<USER>\.claude\prompt_gatekeeper_model_switcher.md` |

---

## 10. Verification -- the state-file design

[Back to TOC](#toc)

Question asked at the v2 review: is the design genuinely based on looking at a recorded

state in a JSON file that keeps getting updated, rather than on inspecting the workspace?

Answer: yes, and after v2 it is exclusively so.

**How the state is produced.** The global CLAUDE.md instructs Claude to write

`task_state.json` with `status: in_progress` at the start of any substantial task and

`status: clean` at the end. The hook only ever reads this file. It never inspects the

working directory, the repository, or the transcript.

**Evidence the convention is honoured in practice.** A search of the BFSI session

transcripts on 2026-09-26 found 32 writes of an `in_progress` state across three separate

sessions, so Claude has been maintaining the file, not merely being told to.

**What the hook does with it.**

| task_state.json says | Hooks report |

|----------------------|--------------|

| `status: in_progress`, file written < 24h ago | DIRTY, with task name, project and detail |

| `status: in_progress`, file written > 24h ago | DIRTY plus a stale warning |

| `status: clean` | CLEAN |

| file missing or malformed | CLEAN (gatekeeper) / UNKNOWN (Stop hook), both with an explicit "missing or unreadable, assuming clean" note |

| file parses but has no `status` field | CLEAN (gatekeeper) / UNKNOWN (Stop hook), both saying "no status field, assuming clean" |

| any other `status` value | CLEAN (gatekeeper) / UNKNOWN (Stop hook), both naming the value and saying "assuming clean" |

Age in the first two rows is the file's modification time (Section 13).

**Known weaknesses of a single state file.** It depends on Claude's discipline; a

forgotten reset leaves a false DIRTY until the stale warning fires. It is one file

shared by all sessions, so concurrent sessions in different projects clobber each other.

A future refinement is to key the state by `session_id` (which the hook already

receives on stdin) so each session has its own record and the hook reports the state for

the session that asked.

---

## 11. Revision history -- v1 integrity review

[Back to TOC](#toc)

An integrity review on 2026-09-26 compared the v1 document against the live files and

tested the hook. Findings and the v2 response:

| # | v1 finding | v2 response |

|---|------------|-------------|

| 1 | `gatekeeper.py` did not compile (nested f-string with backslash escapes, line 276). Because compilation precedes the `ENABLED` check, the hook exited 1 on every prompt even while "disabled". | Stale message built in plain variables before formatting. Compile check added to Sections 4 and 6. |

| 2 | Design assumed the coloured stderr block was shown to the user. Per the hook docs, stderr on exit 0 goes to the debug log only. | User-facing summary moved to the `systemMessage` JSON field. Stderr and ANSI colours removed. |

| 3 | Git corroboration overrode the state file: any modified tracked file produced DIRTY, which was the resting state of the BFSI repo. | Git removed entirely and made a PRIME DIRECTIVE (Section 0). |

| 4 | Substring keyword matching: "settle" triggered Opus via "ttl"; "know" triggered Haiku via "no". | Word-boundary regex matching. Haiku restricted to prompts of 8 words or fewer. |

| 5 | Naive timestamps were treated as UTC, under-counting age by the local UTC offset. | Naive timestamps treated as local time. |

| 6 | `cwd` in `task_state.json` read but unused. | Still informational only; documented as such. |

| 7 | Section 4 embedded an older copy of the script that lacked project, cwd and stale detection. | Embedded copy removed; the live file is the single source of truth. |

| 8 | Section 9 referenced a BFSI memory note that does not exist. | Reference removed. |

| 9 | Sonnet 4.6 hard-coded as default while Sonnet 5 is current. | Default is now Sonnet 5. Price figures marked unverified. |

| 10 | CLAUDE.md demanded state-file bookkeeping while the hook was disabled and broken. | Hook enabled. |

| 11 | Hook read the `prompt` stdin field; current docs name it `user_prompt`. | Reads `user_prompt`, falls back to `prompt`. |

Verification after the rebuild: `py_compile` passes; the source contains no process

spawning; eight sample prompts produce the expected recommendations; the four

false-positive cases from v1 no longer misfire; a 2-day-old naive timestamp reports

roughly 53 hours of age.

---

## 12. Future direction -- LLM-based assessment (planning)

[Back to TOC](#toc)

Status: the options below were the planning record. Outcome, per the decisions at the

end of this section: D's state half is implemented (Section 13), `[check]` mode is

implemented (Section 14), A and C are closed, B is parked, D's continuation hint is

deferred.

### The problem with keywords

Keyword matching cannot tell "what does TTL stand for?" (a Haiku question) from

"rewrite the TTL" (an Opus task). It cannot see that a short prompt like "continue"

is continuing a long-horizon build. And it cannot judge the state at all; it can only

read what Claude last wrote. The proposal is to let a model read the prompt (and

optionally the recent transcript), summarise what is being asked, and base both the

model recommendation and the state judgement on that understanding.

### Constraints any design must meet

1. PRIME DIRECTIVE holds. An HTTPS call to a model API is acceptable. Spawning the

`claude` CLI or any other process is not.

2. Latency is paid on every prompt. Anything above roughly two seconds will be felt.

3. Cost is paid on every prompt. Only a fast, cheap model is defensible.

4. It must fail soft. If the network, proxy or Zscaler state breaks the call, the hook

must fall back to the keyword path and say so, never error.

5. No credentials in code. API key from an environment variable only.

### Options

**A. Claude Code native `type: "prompt"` hook.** Claude Code can run a hook as a

single-turn model evaluation instead of a command. The prompt text is supplied via

`$ARGUMENTS` and the model returns a JSON decision. This is the least code and needs no

API key handling because it rides the session's own authentication. Open questions to

settle with a live test: whether `UserPromptSubmit` supports prompt hooks (the docs do

not list supported events explicitly), and whether the returned decision schema can

carry a free-form recommendation or is limited to allow/block plus reason. There is also

an experimental `type: "agent"` hook that can read files with tools, which could read the

transcript tail to judge task completion, but it is marked experimental and may change.

**B. Direct API call from `gatekeeper.py`.** The Python hook posts the prompt to

Haiku 4.5 through the Siemens proxy with a structured instruction and receives JSON:

`{summary, task_type, horizon, recommended_model, recommended_effort, confidence}`.

Full control over the schema and the fallback. Costs one network round trip per prompt

and depends on the proxy and Zscaler being reachable.

**C. Hybrid (recommended starting point).** Keep the keyword path as the fast lane for

unambiguous cases: very short confirmations, and prompts that contain an explicit Fable

trigger. Call the model (via A or B) only for prompts above a word threshold or with no

keyword hit. Most prompts then cost nothing extra, and the model is consulted exactly

where keywords are weakest.

**D. Ask the main model itself.** Inject an instruction via `additionalContext` telling

Claude to end each reply with a one-line recommendation for the next prompt and to keep

`task_state.json` updated with a short summary. Zero latency and zero extra cost, but it

is self-assessment by the model already chosen, and it only informs the next prompt.

Worth doing regardless, as a complement.

### The bigger prize: LLM-assessed state

The more valuable use of a model is not picking between Sonnet and Opus. It is judging

whether the previous task actually finished. The hook receives `transcript_path` on

stdin. A fast model given the last few turns of the transcript can answer "was the last

piece of work completed, handed off, or left mid-flight?" far more reliably than a file

Claude has to remember to reset. That judgement can then be written into

`task_state.json` (or a per-session sibling) so the state file becomes model-maintained

rather than discipline-maintained.

### Decisions taken

- 2026-09-26: **Option D is approved as an ADDITION to whichever of A/B/C is chosen,

not a replacement.** D cannot see the next prompt, so it cannot judge that prompt's

depth; its job is to keep `task_state.json` honest and to offer a continuation hint

from work already in flight. Where D and the prompt-based recommendation disagree on

the model, the prompt-based one wins. Nothing in D (or any option) switches the model;

only the user typing `/model` does.

- 2026-09-26 (later): **D's state-maintenance half is IMPLEMENTED** (Section 13).

D's continuation-hint half and all of A/B/C remain planning only.

- 2026-09-26: **Option A cannot be gated by keywords.** A prompt hook is a separate

settings entry that Claude Code runs on every prompt; the Python hook cannot switch it

on per prompt and the two cannot communicate. A real keyword-first hybrid (Option C)

therefore requires B, where the model call sits inside `gatekeeper.py`.

- 2026-09-26: **B runs in a separate context.** It is a standalone API call that sees

only what the hook sends it, by default the prompt text. To judge bare prompts like

"continue" it would need `task_state.json` contents or a transcript tail passed in.

- 2026-09-26 (later): **[check] soft-check mode implemented (Section 14). A and C are

CLOSED. B is PARKED**, to be revived only if the user finds they are routinely

skipping `[check]` on heavy prompts. The soft check gives LLM understanding using the

model already in the session, with full conversation context, no second hook, no API

key and no separate context, which removes the reason A, B and C existed.

### Suggested next step

(Superseded by the decisions above.) The earlier plan was to prototype C with B as the

model path behind an `LLM_MODE` switch. That is no longer planned. The only open item

is D's continuation hint, and B stays parked unless `[check]` proves to be skipped on

heavy prompts in practice.

---

## 13. v3 -- State split to end of turn, Option D implemented

[Back to TOC](#toc)

Implemented 2026-09-26, after the discussion recorded in Section 12.

### The problem with showing state on prompt submit

`UserPromptSubmit` fires after the user has typed. Showing the state there tells the

user whether the deck was clear for the prompt they have already sent. The user needs

that information BEFORE typing, at the moment Claude hands control back.

### The split

|---------|-----------|--------|------------|

`gatekeeper.py` still reads the state, because Claude needs it in `additionalContext`

and because the user-visible block keeps a one-line "task in progress -- hold off

switching" warning at the moment they might reach for `/model`. It no longer prints the

full state block.

### state_monitor.py (Stop hook)

- Same PRIME DIRECTIVE as the gatekeeper: reads `task_state.json` and nothing else,

spawns nothing, never blocks, always exits 0.

- Output is one `systemMessage`, for example:

```

STATE [DIRTY] task in progress: 'Writing bfsi-case.ttl' [BFSI] (updated 12m ago)

Phase P1 -- new shared case module

! Hold off switching model/effort until this task is complete

```

STATE [CLEAN] safe to switch model or effort (updated 3m ago)

```

- Stale warning when in_progress for more than `STALE_HOURS` (24).

- Missing or malformed file is reported as `[UNKNOWN] ... assuming clean`.

- Registered in `settings.json` under `"Stop"` with a 5-second timeout.

### Age is measured from file mtime, not the `updated` field

Claude does not know the wall clock. The `updated` timestamps it writes are estimates

and were observed to be hours off. Both scripts therefore take the age from the file's

modification time, which is the true moment of the last write, and use the `updated`

field only as a fallback if the file cannot be stat'ed.

### Option D, state-maintenance half

`gatekeeper.py` now appends an instruction to `additionalContext` on every prompt:

- If state is clean: before ending the turn, write `task_state.json` as `in_progress`

if substantial work is being started; do not write it for trivial Q&A.

- If state is in_progress: before ending the turn, write it `clean` if the task is now

complete or handed off; leave it if still mid-flight; overwrite it if a different

substantial task has begun.

Because Claude's Write happens during the turn and the Stop hook fires after it, the

state the user sees is never more than one turn behind reality.

### Not yet implemented

- D's continuation hint ("the next turn probably wants Opus") -- deliberately deferred

with the rest of the model-recommendation work.

- A watchdog that flags "state not updated this turn" -- the Stop hook has no reliable

turn-start time to compare against. mtime-based age is the interim answer.

- Options A, B, C -- since v4: A and C closed, B parked (Section 12, decisions).

### Verification

Confirmed live on 2026-09-26: the `Stop` hook's `systemMessage` renders in the terminal

and the user sees the STATE line after each turn. No `statusLine` fallback needed.

---

## 14. v4 -- [check] soft-check mode

[Back to TOC](#toc)

Implemented 2026-09-26.

### Why

`UserPromptSubmit` fires after the prompt is sent, so the model recommendation always

arrives one turn late: the prompt has already executed on the current model. The user

wanted a way to have a prompt assessed WITHOUT executing it, decide on the model, and

then run it.

### How it works

Prefix the prompt with `[check]` (case-insensitive, spaces inside the brackets allowed,

must be at the very start):

```

[check] read and summarise the site www.wiki.com

```

Sequence:

1. `gatekeeper.py` detects the prefix, strips it, and runs the keyword heuristic on the

rest as usual.

2. The user-visible block is headed `GATEKEEPER -- CHECK MODE: assessment only, nothing

will be executed`.

3. Into Claude's context it injects a CHECK MODE instruction: do not execute, do not call

tools, do not start the task, do not write `task_state.json`. Reply in under 120 words

with (1) what the request would involve, (2) size and depth, (3) recommended model and

effort with a one-sentence reason, (4) whether the current task state allows

switching. End with exactly: "Switch with /model if needed, then type go." The keyword

guess is passed in so the model can override it.

4. The Option D state instruction is suppressed in check mode, since nothing starts or

finishes.

5. The current model answers with the assessment and stops.

6. The user optionally types `/model <name>`, then `go`. The original prompt is still

in the conversation, so the chosen model executes it from context. No retyping.

### Why this beats a hard block

A hook can block a prompt with exit code 2, but Claude Code erases the prompt, forcing

a retype. The soft check keeps the prompt, costs one short reply, and the assessment

comes from a model that actually understood the request and can see `task_state.json`

and the conversation.

### Caveat

The soft check relies on the model obeying "do not execute". Sonnet and above do.

Haiku may occasionally charge ahead; if that is observed, a hard block (exit 2) for

check mode on Haiku is the safeguard.

### Tests at implementation

|--------|-----------|---------------|-------------------|

| `[check] read and summarise the site ...` | yes | Sonnet 5 | no |

| `[CHECK] implement the ontology` | yes | Opus 5.5 | no |

| ` [ check ] ok` | yes | Haiku 4.5 | no |

| `please check the ttl` | no | Opus 5.5 | yes |

| `the [check] tag in the middle` | no | Sonnet 5 (default) | yes |

---

## 15. v5 -- second integrity review

[Back to TOC](#toc)

A second review on 2026-09-26 compared both live scripts, `settings.json` and this

document after v3 and v4 had landed.

### Code findings and fixes

| # | Finding | Fix |

|---|---------|-----|

| 1 | `gatekeeper.py` treated any `status` other than `in_progress` or `unknown` as CLEAN with the reason "task_state.json: clean", while `state_monitor.py` showed UNKNOWN. A typo such as `in-progress` silently unlocked switching. | Both hooks now name the unexpected value and say "assuming clean". Gatekeeper's injected context shows the reason. |

| 2 | Both hooks skipped age calculation entirely when the `updated` field was empty, even though mtime was available. Contradicted Section 13. | Age is always computed; `updated` is only the fallback inside the age function. |

| 3 | `settings.json` maps the `sonnet` alias to `claude-sonnet-4-6@default` while the hook recommends `/model Sonnet 5`. | Not changed (proxy setting). Recorded in Section 8 and the script header; to be checked live with `/model`. |

| 4 | PRIME DIRECTIVE scope was ambiguous: the Siemens code-scan hook in the same file fetches via `git+https`. | Section 0 now states the directive binds the two gatekeeper hooks only. |

| 5 | `state_age_hours` docstring described the pre-mtime behaviour; `project` and `cwd` unpacked in `main()` and unused. | Docstring corrected; unused values named `_project`, `_task_cwd` with a comment. |

Verification: both scripts compile; a harness with temporary state files confirmed

identical CLEAN / DIRTY / UNKNOWN verdicts from both hooks for: clean, fresh

in_progress, in_progress with no `updated` field and a 30h-old mtime (stale warning

fires in both), `status: paused`, `status: in-progress`, and file missing.

### Document findings and fixes

| Section | Was | Now |

|---------|-----|-----|

| Header | Revised line stopped at v3. | Lists v4 and v5. |

| 0 | Named only the gatekeeper hook. | Names both hooks; scope note for the code-scan hook. |

| 2.2 | Stale detection from `updated`. | From file mtime; unexpected status documented. |

| 3 | settings.json change listed only UserPromptSubmit; claimed no memory notes existed. | Stop block listed; two memory pointers acknowledged. |

| 4 | Replication copied and registered one script. | Both scripts copied, compiled, registered and smoke-tested. |

| 5 | Examples showed v2 state lines with no pointer. | Notes added pointing to the STATE block and the Option D / check-mode context. |

| 6 | One switch documented. | Both `ENABLED` flags documented. |

| 8 | No mention of `[check]`, Sonnet alias, or fail-open status. | Three rows added. |

| 9 | Scope table omitted `state_monitor.py`. | Added. |

| 10 | Behaviour table had no unexpected-status row. | Added; mtime stated. |

| 12 | "PLANNING ONLY. Nothing implemented" and a next step recommending C via B. | Status reflects decisions; next step marked superseded. |

| 13 | "Not yet implemented: A, B, C". | Cross-referenced to the A/C closed, B parked decision. |

### Second pass (same day)

A re-read of the patched files found one remaining seam: a file that parsed but had no

`status` field was described as "missing or unreadable" by the gatekeeper and as

`status='unknown'` by the Stop hook. Both now say "has no status field -- assuming

clean". Doc touch-ups: Section 3 names `[check]` in the gatekeeper row, Section 2.4

lists the full live effort keyword sets, Section 5 Example 2 shows the actual DIRTY

reminder line, Section 10 has the no-status row. Re-verified: both scripts compile;

six state-file scenarios (clean, fresh in_progress, 30h in_progress without `updated`,

no status field, `paused`, malformed JSON) give matching verdicts from both hooks; both

Section 4 smoke tests produce the documented output; `[check]` on a dirty state injects

the CHECK MODE instruction and suppresses Option D.

### Appendix added (same day)

At the user's request the full source of both hooks, `task_state.json` and the two

`settings.json` hook blocks are reproduced in Appendix A for copy-and-paste. Neither

script contains a user path or credential; the hook commands use `<username>`. The

`settings.json` `env` block (proxy credentials, telemetry identity) is deliberately

excluded. The appendix is a plain copy, so it must be re-pasted after every script edit

(rule stated in Section 4). A.5 adds the full Task State Convention section of the global

`CLAUDE.md`, previously only referenced by name, with its two user paths as `<USER>`.

### CLAUDE.md section trimmed (same day)

The section had grown to 65 lines, over half of the global `CLAUDE.md`. Long instruction

files dilute compliance with every rule in them, so it was cut to about 22 lines keeping

only what changes Claude's behaviour: when to write the state file and its six fields,

the `[check]` rule, the PRIME DIRECTIVE in two sentences, and the pointer here. The

PRIME DIRECTIVE rationale and scope note stay in Section 0. A.5 shows the trimmed form.

---

## Appendix A -- Full source of the live files

[Back to TOC](#toc)

Copied verbatim from the live files on 2026-09-26 (v5, second pass). `<USER>` stands for

`C:\Users\<username>`; in hook commands the POSIX form `/c/Users/<username>` is used.

Neither script contains a user path or credential. `settings.json` is shown as the two

hook blocks only: its `env` block holds proxy credentials and telemetry identity and must

never be copied into documentation or between machines.

**Maintenance rule:** whenever `gatekeeper.py`, `state_monitor.py` or the Task State

Convention section of `CLAUDE.md` is edited, re-paste the whole file or section here in

the same session, then run `py_compile` on any edited script.

### A.1 `<USER>\.claude\hooks\gatekeeper.py`

```python

"""

Gatekeeper -- UserPromptSubmit hook for Claude Code.

=====================================================================

PRIME DIRECTIVE

This hook NEVER runs git -- not directly, not indirectly.

It spawns no processes of any kind: no subprocess, no os.system,

no os.popen, no shelling out. Its only inputs are the JSON on stdin

and one file, task_state.json. Its only output is JSON on stdout.

A runtime self-check (check_prime_directive) confirms that no

process-spawning module has been imported, and reports a violation

in the user-visible message if it ever finds one.

=====================================================================

Fires on every prompt submission. Assesses clean state from

task_state.json and recommends a model and effort level based on the

prompt text.

To ENABLE : set ENABLED = True below.

To DISABLE : set ENABLED = False below.

When disabled the script exits silently as soon as it is imported past

the switch -- no output, no context injection.

Output channels (per Claude Code hook docs):

- systemMessage -> shown to the USER in the terminal

- additionalContext -> injected into CLAUDE's context

stderr is NOT shown to the user on exit 0, so it is not used here.

Model cost reference (as recorded Sep 2026, unverified -- check the

current price list before relying on the figures):

Fable 5.1 : most expensive tier -- long-horizon agentic tasks only

Opus 5.5 : $4 / $20 per MTok -- complex reasoning, coding, TTL work

Sonnet 5 : $2 / $10 per MTok -- edits, explanations, medium tasks

Haiku 4.5 : $1 / $5 per MTok -- quick confirmations, one-liners

Note on the Sonnet label: settings.json maps the "sonnet" alias

(ANTHROPIC_DEFAULT_SONNET_MODEL) to claude-sonnet-4-6@default. The

recommendation below says "Sonnet 5". If /model Sonnet 5 does not

resolve through the proxy, either update that env var or change

DEFAULT_MODEL_LABEL / the Sonnet rule label here.

"""

import sys

import json

import os

import re

from datetime import datetime

TASK_STATE_FILE = os.path.join(

os.path.expanduser("~"), ".claude", "hooks", "task_state.json"

)

# -------------------------------------------------------

# MASTER SWITCH -- flip to False to deactivate

# -------------------------------------------------------

ENABLED = True

# -------------------------------------------------------

if not ENABLED:

sys.exit(0)

# -------------------------------------------------------

# MODEL SELECTION RULES

# Evaluated top-to-bottom; first match wins.

# Keywords match on WORD BOUNDARIES: "ttl" matches "ttl" and

# "ttl-file" but not "settle"; "no" does not match "know".

# Fable is intentionally last and has a very high bar --

# it is the most expensive tier and is only justified for

# truly long-horizon, multi-step autonomous tasks.

# -------------------------------------------------------

MODEL_RULES = [

(

"Opus 5.5", "claude-opus-5-5",

"complex reasoning, TTL/SPARQL authoring, ontology work, deep reviews",

[

"ttl", "turtle", "sparql", "owl", "ontology", "rdf",

"implement", "build the", "write the", "generate",

"create a script", "review all", "self-review", "full review",

"architecture", "master plan", "masterplan",

"phase p1", "phase p2", "phase p3",

"validate", "anzo", "graphmart",

(

"Sonnet 5", "claude-sonnet-5",

"edits, explanations, updates, medium-complexity tasks",

[

"explain", "summarise", "summarize", "update", "edit",

"add a line", "what is", "how does", "can you check",

"what does", "describe", "clarify", "in short",

"quick", "brief",

(

"Haiku 4.5", "claude-haiku-4-5-20251001",

"one-liners, confirmations, trivial follow-ups",

[

"yes", "no", "ok", "okay", "thanks", "great",

"go ahead", "proceed", "continue", "sounds good",

"make it so", "done",

(

"Fable 5.1", "claude-fable-5-1",

"long-horizon multi-step autonomous tasks only -- most expensive tier",

[

"full build", "end to end", "end-to-end",

"all phases", "entire p1", "entire build",

"autonomous", "multi-step workflow",

"run the whole", "build and validate and upload",

"run everything", "do the whole",

]

DEFAULT_MODEL_LABEL = "Sonnet 5"

DEFAULT_MODEL_ID = "claude-sonnet-5"

DEFAULT_MODEL_PURPOSE = "edits, explanations, updates, medium-complexity tasks"

# Haiku is only recommended for genuinely short prompts. A long prompt

# that happens to contain "ok" or "yes" is not a confirmation.

HAIKU_MAX_WORDS = 8

EFFORT_HIGH_KEYWORDS = [

"review all", "self-review", "full review", "check everything",

"audit", "validate all", "integrity check", "deep review",

]

EFFORT_LOW_KEYWORDS = [

"quick", "briefly", "one line", "just check", "in short",

]

FABLE_WARNING = (

"NOTE: Fable 5.1 is the most expensive tier. "

"Only use it if this is truly a long-horizon autonomous task "

"that Opus at high effort cannot handle."

)

STALE_HOURS = 24 # warn if in_progress for longer than this

# -------------------------------------------------------

# CHECK MODE

# If the prompt begins with [check], Claude is instructed to ASSESS the

# request and stop, without executing it or calling tools. The current

# model does the assessing, so it uses real understanding and the full

# conversation context, not keywords. The prompt stays in the

# conversation, so after an optional /model switch the user types "go".

# -------------------------------------------------------

CHECK_PREFIX_RE = re.compile(r"^\s*\[\s*check\s*\]\s*", re.IGNORECASE)

CHECK_MODE_INSTRUCTION = (

"CHECK MODE. The user prefixed this prompt with [check]. Do NOT execute the "

"request, do NOT call any tools, do NOT start the task, and do NOT write "

"task_state.json. Instead reply with a short assessment, under 120 words: "

"(1) one line restating what the request would involve; "

"(2) size and depth: trivial / medium / complex / long-horizon; "

"(3) recommended model (Haiku 4.5, Sonnet 5, Opus 5.5 or Fable 5.1) and effort "

"(low / medium / high), with a one-sentence reason; "

"(4) whether the current task state allows switching. "

"End with exactly: 'Switch with /model if needed, then type go.' "

"The keyword heuristic guessed {label}; override it if your reading differs."

)

FORBIDDEN_MODULES = ("subprocess", "pty", "multiprocessing")

# -------------------------------------------------------

# HELPERS

# -------------------------------------------------------

def check_prime_directive():

"""

Return a violation string if any process-spawning module is loaded,

else an empty string. This hook must never shell out.

"""

loaded = [m for m in FORBIDDEN_MODULES if m in sys.modules]

if loaded:

return (

"PRIME DIRECTIVE VIOLATION: process-spawning module(s) loaded: "

+ ", ".join(loaded)

)

return ""

def read_task_state():

"""

Sole clean-state signal.

Returns (status, task, detail, project, cwd, updated) from task_state.json.

Falls back to ("unknown", "", "", "", "", "") if file missing or unreadable.

Status is "missing" if the file parses but has no status field.

"""

try:

with open(TASK_STATE_FILE, "r", encoding="utf-8") as f:

data = json.load(f)

return (

data.get("status", "missing"),

data.get("task", ""),

data.get("detail", ""),

data.get("project", ""),

data.get("cwd", ""),

data.get("updated", ""),

)

except Exception:

return ("unknown", "", "", "", "", "")

def state_age_hours(updated_str):

"""

Return hours since the last write of task_state.json, or None.

Primary source is the file's mtime. The 'updated' field is only a

fallback if the file cannot be stat'ed; naive values are treated as

LOCAL time, because that is how the convention writes them.

"""

try:

# File mtime is the true time of the last write. Claude does not

# know the wall clock, so the 'updated' field is only a fallback.

updated = datetime.fromtimestamp(os.path.getmtime(TASK_STATE_FILE)).astimezone()

except OSError:

updated = datetime.fromisoformat(updated_str)

if updated.tzinfo is None:

updated = updated.astimezone()

delta = datetime.now().astimezone() - updated

return delta.total_seconds() / 3600

except Exception:

return None

def assess_clean_state():

"""

Returns (is_clean, reason, is_stale, age_hours, project, task_cwd).

"""

task_status, task_name, task_detail, project, task_cwd, updated = read_task_state()

# Age comes from file mtime, so it is computed even if 'updated' is empty.

age_hours = state_age_hours(updated)

is_stale = (

task_status == "in_progress"

and age_hours is not None

and age_hours > STALE_HOURS

)

project_tag = f" [{project}]" if project else ""

if task_status == "in_progress":

reason = f"task in progress: '{task_name}'{project_tag}"

if task_detail:

reason += f" -- {task_detail}"

return False, reason, is_stale, age_hours, project, task_cwd

if task_status == "clean":

return True, "task_state.json: clean", False, None, project, task_cwd

if task_status == "unknown":

return True, "task_state.json missing or unreadable -- assuming clean", False, None, "", ""

if task_status == "missing":

return True, "task_state.json has no status field -- assuming clean", False, None, project, task_cwd

# Any other value is a convention breach (typo or unknown state).

# Same handling as state_monitor.py: report it, assume clean.

return (

True,

f"task_state.json status='{task_status}' is not clean/in_progress -- assuming clean",

False, None, project, task_cwd,

)

def kw_match(kw, prompt_lower):

"""Word-boundary match: keyword must not be embedded in a longer token."""

pattern = r"(?<![a-z0-9])" + re.escape(kw) + r"(?![a-z0-9])"

return re.search(pattern, prompt_lower) is not None

def recommend_model(prompt_lower):

word_count = len(prompt_lower.split())

for label, model_id, purpose, keywords in MODEL_RULES:

if label.startswith("Haiku") and word_count > HAIKU_MAX_WORDS:

continue

for kw in keywords:

if kw_match(kw, prompt_lower):

return label, model_id, kw, purpose

return DEFAULT_MODEL_LABEL, DEFAULT_MODEL_ID, "default", DEFAULT_MODEL_PURPOSE

def recommend_effort(prompt_lower):

if any(kw_match(kw, prompt_lower) for kw in EFFORT_HIGH_KEYWORDS):

return "high"

if any(kw_match(kw, prompt_lower) for kw in EFFORT_LOW_KEYWORDS):

return "low"

return None

# -------------------------------------------------------

# MAIN

# -------------------------------------------------------

def main():

raw = sys.stdin.read()

try:

data = json.loads(raw)

except Exception:

sys.exit(0)

# Current docs name the field "user_prompt"; older builds used "prompt".

prompt = data.get("user_prompt") or data.get("prompt", "")

check_mode = CHECK_PREFIX_RE.match(prompt) is not None

if check_mode:

prompt = CHECK_PREFIX_RE.sub("", prompt, count=1)

pl = prompt.lower()

violation = check_prime_directive()

# project and cwd are informational only (kept in the file for the user).

is_clean, state_reason, is_stale, age_hours, _project, _task_cwd = assess_clean_state()

model_label, _, trigger, purpose = recommend_model(pl)

effort = recommend_effort(pl)

is_fable = "Fable" in model_label

state_tag = "[CLEAN]" if is_clean else "[DIRTY]"

# ---- user-visible message (systemMessage) ----

# Model recommendation only. The STATE is shown by state_monitor.py

# (Stop hook) at the end of each turn, before the user types.

lines = [

"GATEKEEPER" + (" -- CHECK MODE: assessment only, nothing will be executed" if check_mode else ""),

f" Model : /model {model_label} (trigger: '{trigger}')",

f" Use for: {purpose}",

]

if effort:

lines.append(f" Effort : consider /effort {effort}")

if not is_clean:

lines.append(f" ! {state_tag} task in progress -- hold off switching model/effort")

if is_fable:

lines.append(f" ! {FABLE_WARNING}")

if violation:

lines.append(f" !!! {violation}")

system_message = "\n".join(lines)

# ---- context injected for Claude (additionalContext) ----

stale_note = ""

if is_stale and age_hours is not None:

stale_note = f" WARNING: state has been in_progress for {int(age_hours)}h -- may be stale."

if is_clean and state_reason == "task_state.json: clean":

state_text = "clean -- safe to switch model or effort"

elif is_clean:

state_text = "clean (" + state_reason + ") -- safe to switch model or effort"

else:

state_text = (

"DIRTY (" + state_reason + ") -- hold off switching model or effort "

"until current task is complete"

)

injected = (

f"[Gatekeeper] State: {state_text}.{stale_note} "

f"Suggested model: {model_label} (matched keyword '{trigger}'; {purpose})."

)

if effort:

injected += f" Suggested effort: {effort}."

if is_fable:

injected += f" {FABLE_WARNING}"

if violation:

injected += f" {violation}"

# ---- Check mode: assess only, no execution, no state writes ----

if check_mode:

injected += " " + CHECK_MODE_INSTRUCTION.format(label=model_label)

# ---- Option D: state maintenance instruction for Claude ----

# Claude keeps task_state.json honest at the END of its turn, because

# a Stop hook then displays it to the user before the next prompt.

# Skipped in check mode: nothing is started or finished.

if check_mode:

pass

elif is_clean:

injected += (

" [Option D] Before ending this turn: if you START substantial work "

"(code, TTL, SPARQL, multi-section docs, a build phase), write "

"task_state.json with status in_progress. Do NOT write it for "

"trivial Q&A."

)

else:

injected += (

" [Option D] Before ending this turn: if the in-progress task is now "

"COMPLETE or handed off to the user, write task_state.json with status "

"clean. If it is still mid-flight, leave it. If you have moved on to a "

"different substantial task, overwrite it with the new task."

)

out = {

"systemMessage": system_message,

"hookSpecificOutput": {

"hookEventName": "UserPromptSubmit",

"additionalContext": injected,

}

print(json.dumps(out))

if __name__ == "__main__":

main()

```

### A.2 `<USER>\.claude\hooks\state_monitor.py`

```python

"""

State Monitor -- Stop hook for Claude Code.

=====================================================================

PRIME DIRECTIVE (shared with gatekeeper.py)

This hook NEVER runs git -- not directly, not indirectly.

It spawns no processes. Its only inputs are the JSON on stdin and

one file, task_state.json. Its only output is JSON on stdout.

=====================================================================

Fires every time Claude finishes a turn and hands control back to the

user. Reads task_state.json and shows the CURRENT state so the user

knows, before typing the next prompt, whether the deck is clear.

This is the "state" half of the gatekeeper, split out from the

UserPromptSubmit hook so the information arrives BEFORE the next

prompt rather than after it.

Output: one JSON object with a systemMessage (shown to the user).

Never blocks. Always exits 0.

To DISABLE : set ENABLED = False below.

"""

import sys

import json

import os

from datetime import datetime

TASK_STATE_FILE = os.path.join(

os.path.expanduser("~"), ".claude", "hooks", "task_state.json"

)

ENABLED = True

if not ENABLED:

sys.exit(0)

STALE_HOURS = 24

FORBIDDEN_MODULES = ("subprocess", "pty", "multiprocessing")

def check_prime_directive():

loaded = [m for m in FORBIDDEN_MODULES if m in sys.modules]

if loaded:

return "PRIME DIRECTIVE VIOLATION: process-spawning module(s) loaded: " + ", ".join(loaded)

return ""

def read_task_state():

try:

with open(TASK_STATE_FILE, "r", encoding="utf-8") as f:

data = json.load(f)

return data, ""

except FileNotFoundError:

return {}, "task_state.json missing"

except Exception as exc:

return {}, f"task_state.json unreadable ({type(exc).__name__})"

def age_text(updated_str):

"""

Return (hours_float or None, human text).

Age is taken from the file's modification time, which is the true moment

of the last write. The 'updated' field is written by Claude, which does

not know the wall clock, so it is only used as a fallback.

"""

try:

updated = datetime.fromtimestamp(os.path.getmtime(TASK_STATE_FILE)).astimezone()

except OSError:

updated = datetime.fromisoformat(updated_str)

if updated.tzinfo is None:

updated = updated.astimezone()

secs = (datetime.now().astimezone() - updated).total_seconds()

hours = secs / 3600

if secs < 0:

return hours, "timestamp in the future"

if secs < 90:

return hours, "just now"

if secs < 3600:

return hours, f"{int(secs // 60)}m ago"

if hours < 48:

return hours, f"{int(hours)}h ago"

return hours, f"{int(hours // 24)}d ago"

except Exception:

return None, "no valid timestamp"

def main():

# Drain stdin so the caller never sees a broken pipe; content unused.

try:

sys.stdin.read()

except Exception:

pass

data, problem = read_task_state()

status = data.get("status", "")

task = data.get("task", "")

detail = data.get("detail", "")

project = data.get("project", "")

updated = data.get("updated", "")

# Age comes from file mtime, so it is computed even if 'updated' is empty.

hours, when = age_text(updated)

lines = []

if problem:

lines.append(f"STATE [UNKNOWN] {problem} -- assuming clean")

elif status == "in_progress":

tag = f" [{project}]" if project else ""

head = f"STATE [DIRTY] task in progress: '{task}'{tag} (updated {when})"

lines.append(head)

if detail:

lines.append(f" {detail}")

if hours is not None and hours > STALE_HOURS:

lines.append(

f" ! flagged in_progress for {int(hours)}h -- may be stale. "

"If the task is done, ask Claude to reset task_state.json."

)

lines.append(" ! Hold off switching model/effort until this task is complete")

elif status == "clean":

lines.append(f"STATE [CLEAN] safe to switch model or effort (updated {when})")

elif status == "":

lines.append("STATE [UNKNOWN] task_state.json has no status field -- assuming clean")

else:

# Same handling as gatekeeper.py: report the breach, assume clean.

lines.append(

f"STATE [UNKNOWN] status='{status}' -- expected clean or in_progress -- assuming clean"

)

violation = check_prime_directive()

if violation:

lines.append(f" !!! {violation}")

out = {"systemMessage": "\n".join(lines)}

print(json.dumps(out))

if __name__ == "__main__":

main()

```

### A.3 `<USER>\.claude\hooks\task_state.json`

Contents change constantly; these are the two shapes Claude writes. Install with the

clean form.

Clean (install this):

```json

{

"status": "clean",

"task": "",

"detail": "",

"project": "",

"cwd": "",

"updated": "2026-01-01T00:00:00"

}

```

In progress (example):

```json

{

"status": "in_progress",

"task": "Writing bfsi-case.ttl",

"detail": "Phase P1 -- new shared case module",

"project": "BFSI",

"cwd": "<USER>\\Projects\\BFSI",

"updated": "2026-09-26T14:32:00"

}

```

### A.4 `<USER>\.claude\settings.json` -- hook blocks only

Merge these two entries into the existing `"hooks"` object. Do not copy the rest of

`settings.json` between machines; its `env` block contains credentials.

```json

{

"hooks": {

"UserPromptSubmit": [

{

"hooks": [

{

"type": "command",

"command": "/c/miniforge3/python /c/Users/<username>/.claude/hooks/gatekeeper.py",

"statusMessage": "Gatekeeper assessing prompt..."

}

]

}

"Stop": [

{

"hooks": [

{

"type": "command",

"command": "/c/miniforge3/python /c/Users/<username>/.claude/hooks/state_monitor.py",

"timeout": 5

}

]

}

]

}

```

### A.5 `<USER>\.claude\CLAUDE.md` -- the "Task State Convention" section

Paste this section into the global `CLAUDE.md` on the target machine. Without it Claude

never writes `task_state.json` and the state signal is dead. Two paths inside it use

`<USER>`; substitute the real user directory. This is the trimmed v5 form (about 22

lines): it keeps every rule that changes Claude's behaviour and leaves rationale, scope

and examples to this document (Sections 0, 5, 13, 14).

````markdown

## Task State Convention (Gatekeeper Hooks)

Two global hooks (`gatekeeper.py` on UserPromptSubmit, `state_monitor.py` on Stop) read

`<USER>\.claude\hooks\task_state.json` and nothing else. Keep it accurate

BEFORE ending a turn; the user sees it immediately after.

- **START of a substantial task** (code, TTL, SPARQL, multi-section docs, scripts, build

phases): write `{"status": "in_progress", "task": "<short name>", "detail": "<optional>",

"project": "<e.g. BFSI>", "cwd": "<working dir>", "updated": "<ISO local time>"}`.

- **END of a task** (complete, handed off, or paused): write `"status": "clean"` with all

other fields empty strings.

- Trivial follow-ups (a question, a one-line edit) need no update.

**[check] mode:** if a prompt begins with `[check]`, do NOT execute it or call tools.

Reply with a short assessment (what it involves, size, recommended model and effort,

whether the state allows switching) ending "Switch with /model if needed, then type go."

On "go", execute the checked prompt.

**PRIME DIRECTIVE (all projects):** these hooks, and any hook written for this user, must

never run git or spawn processes (no subprocess, os.system, os.popen, pty,

multiprocessing). After any hook edit run `C:\miniforge3\python -m py_compile` on it.

Rationale, scope, decisions and full source:

`<USER>\.claude\prompt_gatekeeper_model_switcher.md`

````

---

*End of Prompt Gatekeeper and Model Switcher documentation.*

How to Publish an NFT on OpenSea: Step-by-Step Guide

2025-06-21T07:55:00.000-07:00

📁 Prerequisites

Item	Description
MetaMask Wallet	A crypto wallet to create and sign your NFT
ETH or MATIC	Needed to pay gas fees (ETH for Ethereum; MATIC for Polygon — which is often free to mint)
NFT Content	Your digital asset (image, video, audio, 3D, etc.)

🛠️ How to Publish an NFT (on OpenSea)

✅ Step 1: Set up MetaMask Wallet

Go to https://metamask.io and install the browser extension.
Create a new wallet and save your recovery phrase securely.
Add some ETH to your wallet (buy or transfer from an exchange like Coinbase or Binance).

⚠️ For Polygon (cheaper), you’ll need MATIC tokens and to switch your network in MetaMask.

✅ Step 2: Connect MetaMask to OpenSea

Visit https://studio.opensea.io
Click Profile (top right) → Choose MetaMask
Approve connection in MetaMask — your OpenSea account is now tied to your wallet

✅ Step 3: Create a Collection (Optional)

Go to your profile → My Collections
Click Create a Collection
Add:
- Logo
- Description
- Royalties (% you’ll earn on resales)
- Blockchain (Ethereum or Polygon)

✅ Step 4: Mint (Publish) Your NFT

Click Create (top menu)
Upload your file (image, video, audio, or 3D model)
Fill in:
- Name
- Description
- External link (optional)
- Properties, levels, unlockable content (optional)
- Blockchain: Ethereum or Polygon
Click Create — your NFT is now minted!

✅ On Polygon, this is free. On Ethereum, you may need to pay a one-time "initialize account" fee if it’s your first time.

✅ Step 5: List Your NFT for Sale

Go to your newly minted NFT page
Click Sell
Set:
- Price (fixed or timed auction)
- Duration (e.g., 7 days)
Click Complete Listing
MetaMask will pop up → sign (and possibly pay gas fee if on Ethereum)

🎉 Done! Your NFT is Now Live on OpenSea

Share your NFT link on social media, Discord, or marketplaces
Buyers can now purchase it directly from OpenSea

🧠 Tips

Tip	Why It Matters
Use Polygon for low fees	No gas fees to mint or list NFTs
Add royalties	You’ll earn % on every resale
Include unlockable content	Useful for private files, perks, etc.
Verify NFT visibility	May take a few minutes to appear

==========================================================

✅ Gasless Minting on Polygon (via Rarible or Mintable)

🧭 Why Polygon?

No gas fees (for minting, listing, or transferring)
Fast and low-cost transactions
Fully supported on OpenSea and Rarible

🔧 Option 1: Rarible on Polygon (Lazy Minting)

How to Mint:

Go to Rarible.com
Connect your wallet (e.g. MetaMask)
Switch network to Polygon (you can use Rarible’s prompt)
Click "Create"
Choose Polygon as the blockchain
Upload your file, add title/description
Enable "Free minting" — this is Rarible’s version of lazy minting on Polygon
Sign (gas-free) — your NFT will be visible on your Rarible profile

After Minting:

Your NFT is lazy minted, but still appears on-chain via Polygon metadata
You can list it on Rarible immediately
It will appear on OpenSea automatically after a short delay (indexed by wallet)

🔧 Option 2: Mintable (Gasless Store)

How to Mint:

Visit mintable.app
Create a "gasless store item"
Upload your art and metadata
Choose Gasless (Mintable Store) option — no crypto or gas needed

Notes:

NFTs minted via Mintable’s gasless store are minted off-chain until purchased (like lazy minting)
Once sold/minted, they can be transferred to OpenSea, but won’t show immediately unless manually imported

🌐 OpenSea on Polygon

OpenSea natively supports Polygon
Go to OpenSea, connect the same wallet
Switch network to Polygon
Your Rarible Polygon NFTs will show under “Collected”
You can list them for resale on OpenSea, zero gas

💡 Tips

Rarible lets you set royalties and collection metadata
You only pay gas if you mint on Ethereum — Polygon is gas-free for mint + list
No bridging required if you mint directly on Polygon

How To Hosting Google Sites on own Domain

2025-05-20T19:46:00.000-07:00

Create your website at Google Sites - sites.google.com

When finished design, Publish first. The website is now working on sites.google.com.

To connect this website with your domain name which you purchased from a Domain Registrar, do the following:
On the webpage on sites.google.com/, click on the Settings (Gear) icon
On the Settings dialog, click Custom Domains, then click Connect Domain.

Type in the domain that you own already.
It will check the validity of the domain. If ok, proceed to next step.

If you see this message "This domain is not verified. Please verify your ownership", then click on the link, otherwise skip this section.

This section will prove to Google you own the domain, by creating an extra TXT/CNAME record.
A new dialog will show two options: Domain or URL Prefix
Select the Domain option.

On the dialog: Verify domain ownership via DNS record.
1. Select record type. TXT or CNAME. I choose CNAME because my domain registrar only has this option.
2. Sign in to your domain registrar (e.g. CrazyDomains)
3. Copy the CNAME record below into the DNS configuration.
i) CName Label/Host: asuiasiaafa
ii)CName Destination / Target: aoanofzdof.googlehosted.com
These two values (masked above) will be given by Google.
4.Press verify below.

Reminder: steps 2 and 3 must be performed on the Domain Registrars page, before coming back here to click Verify. By placing the above information on your Domain Registrar, this shows you have control of the domain name, hence proving to Google that you own that domain.

Follow the instructions below to complete the procedure.

Google Sites will show these instructions:
################
Connect to third-party domain registrar
- In a separate tab, sign in to your domain registrar’s website
- Go to your DNS settings
- Create a new CNAME entry
- Under CNAME value or alias, enter www
- In CNAME destination, enter ghs.googlehosted.com
- Note: Your domain registrar might require a full stop at the end
- Save changes
- Come back to this tab and click Done
################

The next section shows the steps for CrazyDomains as the domain registrar. Others may be similar.

Veed.io - An online Video Editing with AI-powered features

2025-02-08T03:13:00.000-08:00

Stumbled upon this online video editor platform while trying to condense video clips taken on my Google Pixel 7 Pro mobile phone. Few quick notes on some cool features that prompted me to share this experience here.

Video Compression includes fps and framesize
Free Account that is usable
Upload and Download that are smooth
Create videos by i) Recording ii) By Video AI (give a description and it produces a video)

Another reason that prompted this blog, is the rather un-intuitive layout and operations for the platform. But since it is quite a nice tool, I thought of giving more details here to make things easy for new users.

Video Editing Features:

FPS - for compression, use this to select a lower framerate. Choices are: 30, 25, 24, 10

Framesize - reduces the image to popular social media formats, eg:

Timeline, splitter, cutter - for slicing and dicing

Voiceover

Some not so cool features:

- you get two free, anonymous, non-sign-in video uploads and edit. Then you need to create an account to do more. You can choose the free plan.

- The interface for the first two free videos are different. Subsequent videos need to be restricted according to the type of plan.

- Free plan features: watermark (based on your name), no privacy (anyone with the link can view your video), 720p, 10min duration per video, 1 GB per video, 20GB storage total.

Hints (for using a Free account):

- Give a short name, even a dot "." - so that the watermark is shorter.

- Permanently Delete video from your account if you want privacy.

How to start? Create New Project

Must do this before it allows you to upload a video, and access the editing tools.

How to GET Video when completed?

Done -> Export

You don't download when you finished creating, editing, compressing the video. You have to EXPORT first. But how to export? You have to click DONE button, since there is no Export button. Then only click Export Video. The export process is where the final video is rendered, using all the changes that we specified.

How to download?

The typical Download icon does NOT download the video. You need to click on one of the 3 buttons below: MP4 (for video) or MP3 or GIF

How to get back to main page, after export and download?

Once finished, and you want to upload or start creating a new video, there is NO back to Homepage or project button. It seems stuck at the download page. So you need to click the VEEP word on the top left corner.

How to NOT Share?

For the free account, all videos are SHARED, unless you Delete Permanently.

Sharing happens automatically after the Export process is finished.

Below dialog shows different ways of sharing.

Although the video is public, people can't see it unless you give them the link.

Linux On Microsoft Surface Laptop

2024-03-08T06:30:00.000-08:00

Found some materials on how to do this.

Firstly the YouTube link with title : How to Install Linux on a Microsoft Surface (Ubuntu 22.04 Linux Surface Kernel)

https://youtu.be/6_EHEmz_j4o

Few things needed:

Linux Ubuntu Iso download
USB key
Software called Rufus

When the above are ready, then proceed

Run the Rufus program with the USB key plugged into the computer.
When prompted, select the Downloaded Ubuntu *.iso for Rufus. Basically Rufus will create a bootable USB with Ubuntu on it.
Plugin the USB onto the Surface
Boot up MS Surface, ensure boot configuration is selected to boot from USB drive.
Go into Ubuntu installation, follow instructions to install, then Reboot

At this point, Ubuntu is installed, you can boot and login. However, lots of the Surface hardware features are missing, e.g touchscreen, rotation of screen. To get these capabilities, we need to modify the Ubuntu kernel by installing a special kernal

Go to Google and search Surface Linux.

Follow the instructions there.

Update 30 Mar 2024

The following is an attempt to make use of a LIVE Linux on a USB drive. The above discussion is still slightly relevant, but several road-blocks are encountered as discussed below.

Rufus vs Universal USB Installer (UUI)

There are various good reviews of Rufus which states some of its advantages, so I won't repeat here. From experience, I can say it is easy to use to write a Linux ISO onto a USB drive and it seemed fast. However, specifically with Microsoft Surface that I tried on, it failed to get pass the Secure Boot (Bitlocker) screen. I changed the options at the MS Surface boot screen on the Security menu, trying all 3 options including no security, but still it would not boot. (Please leave comment, if I did not use correctly - but you must have experience in using Rufus on MS Surface).

Note: I've checked with the Microsoft account specifically to this MS Surface device, and there is no BitLocker key. Yet the device was still unusable.

So then I tried the UUI - and it is similarly as easy to write a Linux ISO to a USB drive than Rufus. This actually was able to go pass the Secure Boot. At the appropriate boot up screen, we should select VTOYEFI option, then followed by "Enroll_This_Key_In_MokManager.cer".

SLAX vs Lbuntu

I chose SLAX because its ISO was under 500GB. After burning this into the USB using UUI, and starting up using the USB, it would not boot. The reason is that it appears UEFI is not fully available for some reason. Switching to Lbuntu instead, and using UUI, the USB was finally able to boot Lbuntu onto the MS Surface.

Now the next problem is that MS Surface Wi-Fi hardware may not have been supported by Lbuntu. So the next step is to find a Linux that supports MS Surface, at least for the Wi-Fi adapter.

Wifi problem:

It seems that the Linux that I've tried, including Lbuntu and Ubuntu above does not recognize the wifi adapter hardware. From internet searches, it seems the hardware is Marvell branded wifi adapter. A few commands to check whether the wifi hardware adapter is detectable or not:

lspci

ip -a

It will be obvious if theses commands do not mention anything about any wifi adapters

Persistence

To consider persistence, that is keeping the changes made to the Live Linux, the overlayfs in Linux is used. A few good references include:

https://www.baeldung.com/linux/overlayfs-usage

https://linuxconfig.org/introduction-to-the-overlayfs

Security

2023-10-12T17:10:00.003-07:00

Hidden Cameras

https://us.norton.com/blog/how-to/how-to-find-hidden-cameras - an excellent list of methods to identify hidden cameras

Will have more in this article ......

iRiver IBC-R6 Bone Conduction Earphone - Manual and Review

2023-01-17T06:34:00.005-08:00

Recently bought this bone conduction earphone from the mature company iRiver of South Korea. You may remember iRiver from the days of really portable MP3 players, recorders and such. It is priced in the mid-range of 65,000 to 70,000 Won. The reason I chose this over no-brand or unheard-of-brands which are less than half the price is because it is from a South Korean company, rather than China. There are more expensive ones of course, such as Aftershock, which has been rebranded as Shokz, but I cannot justify the price to myself.

The first part of this blog would be showing the User Guide / Manual which is originally in Korean. The English translation (via Google Translate Camera function) is also shown below.

The review will be coming soon .... stay tuned

Grand Mafia Strategy

2022-04-09T08:01:00.011-07:00

Rules

City Rules

This can be found in: Event Centre -> Governor's War Season 2 -> Battle for The City Hall -> City Announcement -> Check Announcement

Mansions

Level 17 - Get Babe #3 Julia

Campaign

Normal vs Elite - both have 7 stages.

Each Normal stage has to be completed first, then only the Elite stage can go to the same level of stages.

Elite #5-12 - Bubba - Need Sparrow, Vinny, Mike, Nurse Doxxy, Nioh

Elite #7-12 - Anonymous - Need Sparrow, Big Shot, Bubba, Lok, Nurse Doxxy

Defense

Wall

This is one of the keys to defense against attackers. The higher the level, the better.

In general, go to Investment Center to upgrade various wall defence items.

Within the Wall, the Traps also need to be upgraded.

Enforcers can be selected as Defensive Enforcers within the Wall. Some Enforces are better than others, e.g. Sparrow, @nonymous, Tony, etc.

Radar - built this structure to ensure you get notified when others are attacking you.

Enforcers should return home (from Robbing or other activities), once you know (from the Radar notification) that you are under attack.

Safehouse

Keep Enforcers and Associates in Safehouse if Turf is under attack.

Police Raids

Enforcer - choose the one that is under the Wall category, e.g. Tony or El Cortardo.

Gear up the Enforcer - maximise the biker gear.

Jewels - biker attack and biker defence, wall defence and trap attack

Crew Defense buff - enable this under the Combat buffs

Specialties - normal or Governor - should be all Biker and Crew Def/HP

Reinforce vs Station

Station - will be based on our stats. We can also station our Underboss on the other Turf, but if the battle is lost, then we will lose the UB too.

Reinforce - based on the stats of the other player.

Construction

Workshop

Workshop has links to Set, Armory, Jewels

Materials needed for workshop items can be obtained from Kingpins. Click on Item -> Upgrade -> Select Missing Material -> Method of obtaining

Buildings:

Wall <- Workshop <- Smelter

Training vs Hospital vs Diamond Production

For miniH:

To train T4 bikers takes 6 days 18hr, 240,000 influence Hll events

Given that stats are:

2 training, 2 diamonds

total associates 1.993m

hourly upkeep 5.053m

training speed bonus 229.3%

training time -69.63%

associates/session 15,747

---

hospital capacity: 566/791,764 318.8% 566

Robbery

Clothing to increase speed: electric gun, builder's shirt/boots, investor's trouser/dagger

Clothing to increase load: investor's trouser/pistol, builder's shirt/shoes/shovel

Robbing efficiency - Level 4 resources:

Arms. 1.26m x 14 PTS / 126min = 0.14 pts/min

Metal 0.945m x 14 pts/ 96. min = 0.138 pts/min

Depot 1.26m x 14 pts/ 140mi. = 0.126 pts/min

Diamond 0.4725 x25 pts / 82mins= 0.144 pts/min

Enforcers

Specialties increase: when Exp level of Underboss is increased.

Enforcers level up when: attacking kingpins, go on campaign

Troops increase

- by Enforcer Rank increase

Items

Where to acquire the items that we need?

Go to Faction Shop -> Faction Shop to buy with coins.

Go to Faction Shop -> Broker to buy with gold.

The items are categorised in:

Premium: Direct/Random Relocator

Kingpins

Experience

DMG L1 L2 L3 L4

1 819 1431 2304 3973

2 1638 2862 4608 7946

3 2457 4293 6912 11919

4 3276 5724 9216 15892

5 4095 7155 11520 19865

Governor's War Specialties

DMG L1 L2 L3 L4

1 492 858 1382 2383

2 984 1716 2764 4766

3 1476 2574 4146 7149

4 1968 3432 5528 9532

5 2460 4290 6910 11915

Please excuse the numbers above if the format is jumbled up. The first column is the DMG levels reading downwards. Across the columns are the 4 different levels.

The Levels L1-L4 are the levels of the Kingpins

The DMG is in the game, where if we have enough Energy, we can hit a L1 Kingpin with DMGx2 or DMGx3 etc.

The main question the table above tries to answer is: Should I hit on a L4 OR using the similar energy to hit a L1 by using DMGx4?

The answer from the table is hitting a L1 with DMGx2 or DMGx3 is better than hitting a single (DMGx1) L2 or L3. However, if you can hit L4, then it is better to hit 1 L4 Kingpin (Exp=3973) than hitting an L1 Kingpin using DMGx4 (Exp=3276).

Governor's War

Events Sequence

Day1 : Robbery

Day2 : Street Sweep / Police Station - Kingpins, Action points, Police Stations, family currency/insignia

Day3 : Increase Influence - enforcer wheel, family currency/insignia

Day4 : Speed Ups

Day5 : Kill Event / Massacre Day

Battle

L5 Police Station - Bruiser Square

T3: Bruisers 1.140m Hitmen 1.169m Bikers 0.588m Cars 0.151m

Our Side: Hitman Square UB: Bruiser Mike. Call for Bruisers.

T3: Bruisers 1 Hitmen 1 Bikers Max Cars 0

Enemy has:

L5 Police Station - Bruiser Square

T3: Bruisers 1.064m Hitmen 1.144m Bikers 0.425m Cars 0.0m

Our Side: Bruisers Square UB: Biker Bubba. Call for Bikers.

T3: Bruisers Mine Max Hitmen 0 Bikers Others Max Cars 0

good win

Notes Nokia 8.3 Android 11

2022-03-30T05:43:00.006-07:00

DON'T BUY - Mine got Overheated with no chance of recovery. Bad thermal design.

Recovery Mode

Forgot Password

Missing Back button

Wifi - Hidden and MAC address

Screenshot button missing

This notes may apply to Anroid 11 mobiles in general, although the notes are based on my Nokia 8.3. This is because the Nokia 8.3 is running Android One, which is supposed to be an unaltered version of pure Android.

Recovery Mode

===============

To enter recovery mode:

- plug in USB-C cable

- turn off the phone

- Press Volume Down AND Power button and hold for a few seconds.

Once in Recovery mode, the options are:

- START

- Restart Bootloader

- Recovery Mode

- Power Off

- Boot to FFBM

- Boot to QMMI

Forgot Password

=================

This will WIPE ALL DATA

- Go to Recovery Mode as mentioned above.

- Select Recovery Mode. The Android logo is shown

- Unplug the cable

- Press the Power and the Volume Up key once

- The Recovery Mode menu will show many options

- Choose the Wipe Data / Factory Reset

Missing Back button

====================

By default, Android 11 hides the 3 usual buttons, including the Back button.

To enable these 3 buttons on Nokia 8.3 Android 11:

- go to Settings -> Accessibility -> System Navigation

- Choose between:

Gesture Navigation

3 button Navigation (includes the Back, Home, Apps buttons)

Wifi - Hidden and MAC address

================================

Two important items when connecting to a Wifi on the phone is:

- using a Hidden wifi network

- using the Device MAC address, NOT Randomized Mac.

Unfortunately modern Android phone deliberately make these two security features very hard by HIDING the relevant settings.

On a totally new Android phone, with no SIM card, adding a Wifi network also seems to be a challenge. I forgot the exact details, but persevere and click through all possible options to add the first wifi network.

Before configuring the phone, ensure to

i) change the network Wifi settings, to be it NOT HIDDEN temporarily.

ii) Add the MAC address of the phone

Then go into the phone and start Configuring:

- go to Settings -> Network and Internet -> Wifi

- Click Add Network at the bottom.

- Type in SSID, Security option eg WPA2, Password

- Click Advanced Options

--- In Hidden Network, change to 'Yes'

--- In Privacy, change to 'Use device MAC'

- Click Save and Connect.

Go back to network Wifi and change back to:

- Hidden Network enabled

Screenshot button missing

=============================

In previous Android or other handset, the screenshot features is available in two places:

1. Swiping down from the Top of the screen will reveal apps settings like WiFi connection, GPS, HotSpot, Bluetooth, etc, AND Screenshot.

2. Pressing the Power and Volume Down button, will trigger screenshot.

However the above methods is no longer available in Nokia 8.3 running Android 11. It may also be the same for other mobile brands using Android 11.

The Screenshot however is still available in a new spot. This applies to whether using 3-button navigation or Gesture navigation. To trigger Screenshot, simply go to the screen that shows the multiple background apps.

i) Using 3 button navigation, the Background Apps is available by pressing the Squre icon button. Then the words Screenshot will appear on the bottom.

ii) Using Gesture navigation, the Background Apps is available by Swiping upwards from the bottom of the screen. Then the words Screenshot will appear on the bottom.

I can imagine this is a very smart and intuitive location, even though it is very annoying if we got used to the previous methods. It is intuitive because the Screenshot is taken for the whole screen. What better location than to put the Screenshot at the Background Apps area, where we can scroll through different Background Apps to take screenshot for.

NOTE: The word background does not mean wallpaper background. It means the multiple apps that we open, but it is hidden by the recent app. So these background apps are the ones still running but not on the front screen.

Google Drive Desktop - Different modes of Syncing and Offline

2022-01-31T18:02:00.003-08:00

A bit of background first on Google Drive:

Google Drive have been in existence over many years. It's basically an online, browser based, file storage where you can drag-n-drop any files from your computer onto the webpage of Google Drive. Then there are specific Google office apps which are equivalents to Microsoft Office such as:

Docs (like Word)

Sheets (like Excel)

Slides (like Powerpoint)

.... and even better new apps like: Forms, Drawings, etc

Basically Google Drive allow you to have a file system / file storage plus working on some of those files online from a browser webpage.

Google Sync

Then came the little technology that allows us to install a component on our computer, which then automatically syncs between Google Drive and our computer. This means that we see the Google Drive files and folders on our computer, through File Explorer - as if those Google Drive files are on our computer.

The reason for this blog is that the Google Sync technology has undergone a few iterations with new names and so creating some amount of confusion. Every few years coming back to this technology again, the name has changed. I may be mistaken, but I roughly remembered the earlier name as Google Sync -> then it became Backup and Sync -> now it became "Google Drive Desktop"

Google Drive Desktop

This post is about the new syncing technology called Google Drive Desktop (now that we are sort of clear on the history) and we won't mention the previous products from this point on.

Installation

Simply open your favourite browser and search engine and type: Google Drive Desktop

Then click on the results as shown below.

Installation Problems

It is worth mentioning a few of the installation problems I encountered which does not seem to have a specific or logical solution - but I managed to solve it and will share it here.

The problem occurs after installing the Google Drive Desktop, the little icon in the taskbar is visible but nothing much else. There is a button or link to prompt us to sign in to our Google account or sign in to Google using the web browser or various other ways to prompt us to sign in to Google. But after signing in, still there are no options in the Google Drive Desktop taskbar icon except to sign-in. So I encountered this loop where I keep signing in and there are no results after that. Right click on the taskbar icon and select Preferences, and a window seems to pop up and disappear immediately. There is also a new icon on the desktop itself, and that also prompts us to sign-in, again repeated sign-in had no results.

You may also see the 'Success!' message below after each sign-in attempt, but we may still get nowhere, i.e the Google Drive files is still not showing in our local computer.

Here are a few things I tried that may in combination provided the solution:

- Restart your computer, perhaps do this two or three times.

- Definitely try signing in two or three or more times after each step.

- When there is an opportunity to sign-out, then completely sign-out of any Google accounts.

- Finally when there is an option to 'Disconnect' from Google Drive, then click Disconnect (this may appear in a smaller window)

Summary - keep on trying various things to sign-out, disconnect etc and signing in again until it works.

Installation Working

When the installation is successful, then in Windows File Explorer, it should show the Google Drive like this:

Syncing Warning

1. By default all files in MyDrive on Google Drive will be synced and appears in File Explore on the local computer

2. Deleting a file on the local computer, e.g. through File Explorer, will ALSO delete the file in the cloud Google Drive.

For my usage, I prefer NOT to sync everything between the Google Drive and my computer, so I prefer to choose which folders in Google Drive need to be synced to my computer.

The next section will discuss more on how to configure the other modes of syncing, and not deleting the files on the cloud when the local file is deleted.

"Set up offline access" - Right-click on the file or folder you want to make available for offline use. Next, choose "Available Offline" under the "offline access" menu.

Syncing with Offline access

Several modes are described here: https://support.google.com/a/users/answer/9308619

Essentially with the offline access mode, we can work on the documents while temporarily not having internet connection. For example, this could be on a flight, in a park, in a coffee shop where we don't trust their public wifi, etc.

1. Working with non-Google files (ie not Docs, not Sheets, etc)

Assuming Google Drive for Desktop is installed, open the Google Drive folder. Select the file or folder to be accessed offline. Right-click on it, and select Drive File Streama and then Available offline.

2. Working with Google files (eg. Docs, Sheets, etc)

Install the Google Docs Offline extension. In Drive, click Settings, thenSettings.
Go to the Offline section, check the Create, open and edit your recent Google Docs, Sheets, and Slides files on this device while offline.
Right-click a file and turn on Available offline.

3. Working on mobile phones

On your mobile device, open the Google Docs, Sheets, or Slides app. Tap Menu and thenSettings. Turn on Make recent files available offline.

Syncing Mode Preferences

As shown below, there are at least 3 different syncing modes. To come to these options, right click on the Google Drive Desktop taskbar icon, then select Preferences.

1. Google Drive - My Drive - Stream files

The files are mostly in the cloud (not on our computer). But when we need to work on the files with no internet connection, we can make the files and folders available offline. See section above about working with offline files.

2. Google Drive - My Drive - Mirror files

The files are stored both in the cloud of Google Drive and also on the local computer. The files on the local computer are available to work with, even when there is no internet. There is no extra steps to make these files to be offline, since there is always an offline or local copy already.

3. My PC - This option allows us to select files or folders originally on our local computer already, to be stored / backed-up on the cloud. Click on the Add Folder button to select which existing local folders should be placed on the cloud.

When everything is working, opening the taskbar icon for Google Drive Desktop should show something like this:

Setting up a Secured Email Server

2022-01-31T17:52:00.000-08:00

This article is Work In Progress....

There are lots of good info on the web about setting up email servers. So this article will start with some links to those sites.

References:

https://helpdeskgeek.com/how-to/how-to-set-up-your-own-email-server/

Mail Server - it looks like the most popular on is 'hmailserver' - https://www.hmailserver.com/download/

Metaverse and the Bitcoin Blockchain CryptoCurrency

2022-01-05T06:07:00.003-08:00

Metaverse - What is it?

The metaverse has been around for a few decades in one way or another. However it is not until recently when Facebook chief - the Zuck - announced the new name Meta for his company that the Metaverse has come into heightened attention. Here are some definitions of the Metaverse typically found on Google search:

Wikipedia - "A metaverse is a network of 3D virtual worlds focused on social connection. In futurism and science fiction, the term is often described as a hypothetical iteration of the Internet as a single, universal virtual world that is facilitated by the use of virtual and augmented reality headsets"

Nvidia - "The metaverse is a shared virtual 3D world, or worlds, that are interactive, immersive, and collaborative. Just as the physical universe is a collection of worlds that are connected in space, the metaverse can be thought of as a bunch of worlds, too. Massive online social games, like battle royale juggernaut Fortnite and user-created virtual worlds like Minecraft and Roblox, reflect some ..."

Bybit - "Living, working and playing in an alternate reality requires funding, and that means cryptocurrency. Just as there are several metaverses to use, there are also multiple cryptocurrencies. Understanding the options, differences, and pros and cons f each one can help you make the best investment decision for your needs.

When I first encountered the hype about the Metaverse, it sounded very much like Virtual Reality (VR) - which was the big thing touted in the late 80s and early 90s. VR has not really taken off in the big way, although there are definitely some tangible benefits realised. Things like pilot training simulators and immersive technology certainly have their niches. There could even be a revival in the form of Google Glasses and the Oculus devices. Thinking a bit deeper, VR is usually associated with the technology that allows the 3D immersive experience. Although the implementation of the Metaverse is also dependent on technology, the Metaverse is much more than about the 3D reality aspect - but it seems to encompass all aspects of the virtual world itself, including commerce, way of life and much more in this alternative metaverse.

The life and commercial aspect of the Metaverse is where cryptocurrency comes in. The quote by Bybit above says it precisely. What currency is better suited to a virtual meta world, then a virtual meta currency embodied by the cryptocurrency blockchain?

Here are some of the up and coming cryptocurrencies that may follow the development of the Metaverse:

ALIEN WORLDS (TLM)
Atari Token (ATRI)
Bloktopia (BLOK)
Boson Protocol (BOSON)
CEEK VR (CEEK)
Chromia (CHR)
CryptoPlanes (CPAN)
DEAPcoin (DEP)
Decentraland (MANA)
inSure DeFi (SURE)
IOTEX (IOTX)
METAHERO (HERO)
MINIGAME,
MRE
METAL
NJF
Polygon (MATIC)
Radio Caca (RACA)
RMRK (RMRK)
Sandbox (SAND)
Solana (SOL)
SQUID,
Starlink (STARL)
TERRA VIRTUA KOLECT (TVK)
Theta Network (THETA)
Torum (XTM)
UFO Gaming (UFO)
Verasity (VRA)
Victoria (VR)
Vulcan Forged (PYR)
WAX (WAXP)

DVB-T + DAB +FM - Software survey

2021-09-10T06:42:00.003-07:00

Bought an el-cheapo Digital TV (DVB-T) USB stick which also has Digital Radio (DAB) and FM Radio - what more could I ask for?

Actually I would ask for an actual software to come with that. As with all things in Ebay, there is a reason why they are cheap. The advertisement itself shows nice and flashy TV pictures on a software. It's only in the fine print of the Package contents that says the software is a Trial Version. I did read that in the ad, but subconsciously put that aside. So now, I'm left with a USB stick with drivers installed but nothing to play with. I don't think I want to touch Windows Media Center, though I guess that is an option to some people.

So the point of this post is to collect and comment of my research on the software that can work with the newly acquired DVB-T stick. Here goes..... (perhaps starting with the paid software, then saving the best free ones for last).

DVB Viewer - http://www.dvbviewer.com/en/index.php?page=features

Cost around 20Eu - which is not a bad price. However there are paid add-ons such as Media Server add-on and Video Editor add-on. On Screenshot pages shows it looks very professional. The Features pages is very comprehensive and also list a lot of TV cards that it supports. Unfortunately mine is a generic brand and I don't expect to find it on the list. The payment is by bank transfer and you put the description of the bank transfer as DVBViewer + email. So it feels quite old school and an independent developer (not a commercial company), and this is one of the positive point for me.

AltDVB - https://www.videohelp.com/software/ALTDVB

Looks like it is free and is under active development, since the last update at the time of writing is May 2021. It's meant to work with DVB-S (Satellite, meaning worldwide signals are available. The T in DVB-T stands for Terrestrial, meaning the local stations). It's 11Mb, its portable, and it has a whole list of Changelog and Release notes. It has its own YouTube subscription channel to explain how to use it.

ProgDVB - https://www.progdvb.com/progtva_download.html

There is a paid version with the title name and there is also a free version called ProgTV. The free version won't support recording and is around 11Mb. It's supposed to let you watch digital TV and listen to radio channels. The paid version supports IPTV, DVB-S/S2, DVB-C (cable) and more.

Media Portal - https://www.team-mediaportal.com/mediaportal/about-mediaportal

This looks like a very complete media center - a full fledged solution. So its ability to play DVB-(C/S/T) is almost drowned out by all the other features. Incredibly, it's not only free but it's open-source too. When it comes to popular software that non-technical people use and download, there is generally a risk of using Free software on the internet. However when a software is open source, like Media Portal, the risk is reduced because the source code is available for the world to see. (this is a general statement about truly open source software and it is not an assessment of the security and safety of using Media Portal). Only drawback is that some DAB (digital radio) functionality may not be fully supported yet.

Review - Antec C40 CPU Cooler

2021-07-09T19:00:00.008-07:00

Is a CPU Cooler really necessary? Is it all hype? Or does it actually work? Or will it be much better than the stock CPU coolers that come together with the original CPUs.

In this simple, unofficial review of the Antec C40 CPU Cooler, I hope to answer some of those questions from my experience with this product. Firstly, for all the official information, please go to the following sites, so I won't repeat the stats of the device in this post:

https://www.antec.com/product/cooling/c40

(Apologies for not having a real photo of the actual cooler. I was too excited to install it before thinking about taking photos. The product link should have many photos of this product)

Why do I need a CPU cooler?

My Windows PC has been turning-off by itself at irregular and unpredictable times. Sure most of the times it is because of Windows - and I am never shy of blaming Windows because most of the time it is Windows' fault. I've checked for drivers incompatibilities, new programs that may cause crashes, anti-virus/anti-malware, plugins misbehaving, Windows Update. But none of this were the reasons. Good for Windows that it is not the problem this time.

By the way, the effect is not really the PC 'crashing'. What happens is that while working on the PC, the computer literally turns-off or powers-off, the same effect as if someone just pull out the power plug.

So this can only be two things:

Power Supply Unit
Overheating CPU (either motherboard or CPU triggers a shutdown to prevent damage)

The Power Supply Unit problem will be very difficult to check. Perhaps qualified electricians can use a multimeter to check a few points (DO NOT TRY THIS). But most PC enthusiasts way of testing is to try a different Power Supply and see if the problem exist. In addition, this problem happens at totally different activities while working on the PC.

Although it looks random, the pattern of the auto turn-off problem emerges. It happens when the computer is left running for some time. It may also happen when doing heavy browsing. It feels more and more like a heat problem. But SpeedFan program says the temperature is between 45-60 degrees. This does not seem to be overly critical although it is high.

Then one day I rebooted, when into BIOS and check the temperature from the BIOS stats, and it is 80'C degrees. Obviously SpeedFan is wrong! The PC is placed at a corner next to a tall filing cabinet, which I thought would have sufficient airflow since it is not tightly cramped, but apparently not. Bringing the PC out of the corner, and removing the side panel of the motherboard reduced the temperature to 60-70'C degrees.

So definitely temperature is the most likely culprit. Although 60-70'degrees may not cause the problem anymore, but I would need to place the PC back to its original position, hence I thought of purchasing another CPU Cooler to replace the stock standard CPU cooler that came with the original CPU.

CPU Socket Type

My desktop PC is based on an AMD APU (CPU + graphics) of FM2 socket type. So I did a whole lot of research of price vs functionality of CPU coolers before selecting this. What I did not realise that was motherboard was FM2+ socket type until after the purchase. However it turns out to be fine since FM2/FM2+ are compatible not only in terms of the motherboard but also the Antec C40.

In fact the Antec C40 is compatible against a variety of AMD CPUs(see product link above or specs in the images above), but it is also compatible with some types of Intel CPUs. For the Intel CPUs, Antec C40 provides an extra harness / frame to screw onto the motherboard (screws provided), on which to secure the CPU cooler. In addition, Antec C40 also comes with a thermal paste, which MUST be applied between the CPU and base of the cooler when installing it.

Product Selection

So apart from the price / functionality, why exactly did I choose this among the many other choices:

Antec seems to be a specialised brand when it comes to CPU cooling. Other brands which I seriously considered were Coolermaster and Thermaltake.
The Copper base was an important point for me.
The weight of the cooler - it is not the lightest but quite reasonable given the dimensions.
The cool factor from the blue LED lighting.

Installation

Before installation of the Antec C40, the original stock standard AMD CPU cooler fan has to be removed. These are the steps I follow - and I do not guarantee any safety - please read other instructions or manuals before doing this.

Uninstalling the AMD stock standard CPU cooler:

Switch of the PC and all connected equipment.
Unplug everything connected to the PC.
Open the CPU case and make sure you touch the metal from to unearth any static charge.
Reposition the CPU case in a comfortable position, with proper lighting, so it is easy to work with.
Gently move any wires aside.
Unlock by pressing the lever on one side of the AMD stock standard CPU cooler. This type of cooler is extremely easy to remove. Once unlock, gently and lightly tilt both ways to let the CPU cooler unhinge from the motherboard latches. NEVER EVER use force. If anything does not move, just tilt or change some other position.
As you lift up the old CPU cooler, you will see some old thermal paste on top of both the CPU and the base of the old CPU cooler. Clean the thermal paste on top of the AMD CPU by rolling the tip of a cotton butt on it.

(Old AMD stock standard CPU. The best thing about this is the super easy way to install/remove due to the excellent lever design. The Antec C40 on the other hand is hard to clip on, and even harder to unclip to remove)

Installing the new Antec C40

Unpack the Antec C40.
Ignore the screws and square harness. Those items are for Intel CPUs.
Test Run Only: Gently lower the Antec C40 on top of the AMD CPU. Practice to latch one side of the CPU Cooler onto the motherboard around the CPU - just to experience any challenges or difficulties. Get a feel of how difficult or easy it is to secure the latch but DON'T do the actual attachment yet.
Use the thermal paste supplied by Antec and squeeze a light amount on top of the AMD CPU. Gently spread the paste with the thermal paste tip, then use a small flat thin cardboard to evenly spread the paste on the CPU.
Get the Antec C40 cooler AND REMOVE THE THIN FILM from the base of the C40 cooler.
Lower the C40 down on top of the AMD CPU. In my case, lowering the side opposite to the latch until it hooks onto the CPU edge was actually quite easy - to this at an angle.
When one side is latched, then very very gently tilt the CPU cooler to be horizontal, to latch on the other side, in order to clip it on. This is the hardest part. You need to apply force, but applying too much force may damage the CPU.
When securely attached, close the PC case, attach the PC components again, restart the PC and go to BIOS screen.

Problem Solved

Is a CPU Cooler really necessary? Is it all hype? Or does it actually work? Or will it be much better than the stock CPU coolers that come together with the original CPUs.

YES, it is necessary. No it is not hype. Yes it does work. Yes, it is definitely better than the AMD Stock Standard CPU Cooler.

Actually the first time I installed it, the BIOS showed 80'C degrees. That was totally unexpected. At least if it was like 60-70'C degrees, that would be similar to the old AMD CPU cooler - that would be understandable. But why would the new Antec C40 produces 80'C degrees when first installed. After checking this and that, with the PC case still open, there seems to be a shiny border between the CPU and the base of the CPU Cooler. Then the shocking realisation that I actually forgotten to remove the thin film packaging on the C40 cooler's base as described in step 4 above.

So after uninstalling the new C40 cooler (uninstalling is even more difficult when trying to unclip the new C40 cooler), remove the thin file at the base of the cooler, then reinstall everything again, the PC was rebooted. Now the very good surprise was that the temperature is hitting about 40'C degrees only. What's more when I place my hand near the CPU cooler fan, it is actually cool air, instead of the hot air I previously felt.

When Windows was restarted, running many applications, browsers, etc to test, the temperature was much lower than with the previous old AMD cooler (actual numbers given by SpeedFan were wrong in absolute terms, but the temperature readings are significantly lower with the new Antec C40 cooler). So the conclusion, at least on my particular AMD FM2 system, the Antec C40 cooler definitely show a dramatic reduction in CPU temperature and the PC does not switch off by itself anymore.

Below image shows the Antec C40 in all its glory (PC case is open)

Online Development Tools

2021-05-14T07:30:00.007-07:00

This post is a collection of useful tools for the programmer. The list will be updated as necessary:

https://gist.github.com/discover - Gist is a way to share codes and snippets with others. Every Gists are individual git repository and this is forkable and usable.

https://ideone.com/ - No need for any tools or installing compiler and editors. Ideone is capable to compile over 60 programming languages.

https://sqldbm.com/Home/ - go to the website and start building your database. Supported database types

SQL server

MySQL

PostgreSQL

Another main facility here is work with the term in a collaboration. Developers can work remotely on a single project through this platform.

https://www.figma.com/ - Figma is a prototyping tool. Just go to the web and start building your design and save online.

https://coggle.it/ - This is a mind mapping application also applicable for structured documents like document trees.

Review - Machine Learning For Absolute Beginners - Oliver Theobold

2021-04-23T21:24:00.001-07:00

Machine Learning For Absolute Beginners: A Plain English Introduction (Second Edition)

Oliver Theobald

This book at Amazon

ISBN-10 : 1549617214

ISBN-13 : 978-1549617218

There is a wealth of information out there on the subject of Machine Learning (ML) especially over the last 10 years. There are books with catch-phrase titles but lacking in substance. Conversely there are books which dwell too deeply into certain kinds of programming framework for ML (nothing wrong with that). For a data scientist, there are not many books out there which cover a broad spectrum of ML, yet with substance on each topic. 'Machine Learning for Absolute Beginners' by Oliver Theobold seems to be one of these rare gems that covers ML broadly and capable of explaining important concepts without too much mathematics or code snippets. Despite the title, a seasoned data scientist may yet find this as a valuable reference.

Following a pleasant introduction to ML and an overview of a typical workflow, it discusses in detail the 3 classes of ML: Supervised, Unsupervised and Reinforcement Learning. It describes a special case of Reinforcement Learning known as Q-Learning. This is followed by a chapter on ML Toolbox where it discusses the data requirements, the infrastructure, the algorithms and the visualisation options that are available. Here it explores the various programming languages (Python, C, R, etc), the cloud platforms (Azure, AWS, Google) and the algorithm frameworks (Tensorflow, Caffe, Torch, etc).

The chapters on data preparation and feature selection covers a lot of the techniques as well as the motivation behind them. These include row and column compression, one hot encoding, binning, treatment of missing data, normalization and standardization. Partitioning of data and cross validation (k-fold) are discussed as the final stages of preparing the data before model training.

The next two chapters were devoted each to Regression and Clustering respectively. These are perhaps the two foundational families of algorithms which are also known outside the context of ML. The difference between Linear and Logistic regression conceptually and applicability to real scenarios were well illustrated. A very simple hand calculation shows how linear regression really works. Logistic regression is then explained by contrasting its usage with linear regression. Similarly the concepts and application for k-Nearest Neighbours and k-Means Clustering for supervised and unsupervised learning were well explained, including the reasonings behind the algorithms.

Machine Learning For Absolute Beginners: A Plain English Introduction (Second Edition) (Machine Learning From Scratch Book 1)

Bias and variance has a short chapter by itself and is enough to explain with sufficient details. Here is another example that brings this book above other ML books which just focus on coding. The understanding of the interplay between bias and variance, which is also emphasized in Andrew Ng's Machine Learning course, differentiates between a data scientist and an ML coder.

Next two chapters deal with the advanced algorithms Support Vector Machines (SVM) and Artificial Neural Networks (ANN). SVM is contrasted with Logistic regression, with explanation of the hyperplanes concept and the margins around the boundary for SVM. ANN concepts were explained from the basic components of neurons and activation functions, building up to the perceptron with mathematical examples for very simple cases. Multilayered Perceptron (MLP) and the various Deep Learning techniques were briefly discussed.

While ANN may be very effective in some cases, it is well known for its lack of explanability (except perhaps with recent developments in SHAP, ICE, LIME, etc). On the other hand Decision Trees has often been hailed for its high explainability nature. So a decent chapter is devoted to Decision Trees with simple mathematical calculations of entropy - which is key to decide on how to split the nodes of the tree. This is expanded to the advanced trees family including Boosting, Bagging and Random Forest and when to use them effectively. This is followed by a short chapter in Ensemble Modelling, where the Stacking method is also discussed.

The last three chapters, finally but rightly put, deals with introducing the development environment and the tool necessary for machine learning work. These include using the anaconda environent to program in the Python language and using the Panda library's dataframes. It also discusses the concept of model optimization and illustrated using the Grid Search technique. Towards the end there is a source code for a simple but complete Python code for an ML workflow, recommendation of other useful books, an Appendix on the introduction of Python but what I consider most useful is pointers to a few free datasets.

Help - Ping request could not find host ... DNS problem

2021-03-20T06:20:00.003-07:00

You may have seen this message before:

Ping request could not find host www.cnn.com. Please check the name and try again.

There could be many things that can go wrong with the networking that caused this. Ultimately it is very likely the DNS that is the problem.

Firstly, let's simply go through a few troubleshooting options - just to rule out it is not because of the them. Do one step at a time, check the WiFi and if it works, don't need to progress to the next step.

1. For older laptops, believe it or not, there is actually a slider switch to click the WiFi on or off. Check this if you have it.

2. On Windows, on the TaskBar, ensure that the Wifi (not any particular Wifi network yet) itself is turn on. The WiFi can be either On or Off or Flight Mode or something else.

3. Check that the Wifi is connected to a particular WiFi network. Make sure it says Connected and Secured. And there is no yellow exclamation mark.

4. Open up CMD command terminal, type:

ipconfig /release

ipconfig /renew

ipconfig /flushdns

5. Reboot the computer.

If all else does not work, it is now time to suspect the DNS.

The DNS, in layman's term (you can Google for the exact definition), is directory service that lookup the URL you type and translate to an IP address. Its like a Post Office that receives an address and then go to that address. Our computer need to have the address of the DNS server itself - eg. we need the POST OFFICE's address, so that we can give them our letter.

The so somehow, our computer needs to know which DNS IP address to use. Most of the time, this is hidden from the user, that is why most computer user don't have to deal with it and so don't understand it. It can be automatically set on the modem or router, and also optionally automatically set on the Windows network settings.

So why should there be a problem when the DNS working nicely behind the scenes one day, then the internet is not working the next day? There could be many answers, but a recent experience has shown that some software, including VPN software can go it to the network settings and change the DNS address.

Hence one more solution to above error message is to change the DNS address on the Windows networking level. Whichever Windows version you have,

- find your own way to the 'Network Connections' page or 'Change Adapter Settings' and you can see a page with a list of your network (ethernet, Wifi, VPN) adapters.

- Right click on the Wifi adapter, if you are using the Wifi adapter.

- Choose 'Internet Protocol Version 4', and click on the Properties

- Go to the section called 'Use the following DNS server addresses', and add 'Preferred DNS' and 'Alternative DNS'

Some of the free DNS addresses are:

Quad9 - known for security

9.9.9.9, 149.112.112.112 (Secured)

9.9.9.10, 149.112.112.10 (Unsecured)

Google - you know them

8.8.8.8, 8.8.4.4

Cloudfare - known for speed

1.1.1.2, 1.0.0.2

OpenDNS - mature and known for security,

208.67.222.222, 208.67.220.220

CleanBrowsing - known for parental filtering

185.228.168.168, 185.228.169.168

Notes Crypto Coin (CRO)

2020-10-07T00:05:00.003-07:00

Recently discovered ths exciting new crypto coin. There are a few features: - staking - The Syndycate https://www.securities.io/investing-in-crypto-com-cro-a-comprehensive-guide/

Notes LinkedIn

2020-09-12T19:26:00.004-07:00

NotesLinkedIn

=================

How to Print Messages to PDF

How to Block someone without them knowing

How to Print Messages to PDF

================================

Printing to PDF is a very simple thing, or it should be. But by default, it seems very difficult to do to get the formatting just right. It is either cut off on the right hand (maybe we can change to Landscape). But then it only prints a little bit of the message on one page.

How to we print the many items of a very long message conversation? The trick is as follows.

- Use Chrome Browser

- Click Messaging on the top horizontal panel.

- The main screen has a left panel of various people, and the middle panel has the main message history of a chosen person.

- On the left panel, click on the person whose message you want to print, and check that the correct message history is on the main panel.

- For privacy, if you want to hide the people on the left panel before printing, go to the left panel, click on the triple dots on top, and select 'Manage Inbox Request'

- On the middle message panel, scroll up to see the start of the messages you want to print.

- Press Ctrl-P, choose Save as PDF.

- In the browser Print panel, Portrait was enough for my printing. But you can change to Landscape.

- In the browser Print panel, in Scale, choose a smaller number say 70% and try a few different numbers until the size and content of messages is OK for you.

- Then click Save. This will produce a PDF file.

- Open the PDF and print as usual.

The main step above is to choose the scaling to make sure it fits enough information of the messages you want to print.

How to Block someoone without them knowing

============================================

No problem, LinkedIn does the block discreetly. It says:

"The blocked member won't receive any notification of this action."

in here: https://www.linkedin.com/help/linkedin/answer/47081

The steps are very simple and listed on the link above.

Basically you have to go to that person's page, click on More, select Report/Block.

When a few options are presented, click on the option that says "Block [user name]". Then click Block.

Note: Blocking is different from Removing a Connection. With blocking it seems you are still connected but would not be able to see their profile, updates and cannot message them anymore.

To unblock is a bit different. Go back to your main page.

On top, click Me, click Settings and Privacy, click Block and Hiding, click Block and select Change. Then choose the person you want to block.

Whaling and Social Engineering by a LinkedIn Babe

2020-09-12T09:34:00.002-07:00

On LinkedIn, I have been recently approached by a very professional seeming young lady. Have you had that experience? Then read on......

(Google Reviewers, please do read carefully before making any decision).

Firstly, I am a male, and I am susceptible to be very friendly with females who are friendly to me (I accept not all males feel the same). Female readers are very welcome to leave your comments, but please understand our weakness.

This article is about an experience which can potentially lead to severe security compromise for the victim, their relatives, friends, colleagues and employers. This article is about a potential account of a whaling or social engineering attempt.

There are various definitions of whaling or social engineering, but let's just use the definition below as an example (not that it is the 100% correct definition), so that we have a rough idea to proceed.

https://searchsecurity.techtarget.com/definition/whaling

"A whaling attack, also known as whaling phishing or a whaling phishing attack, is a specific type of phishing attack that targets high-profile employees, such as the CEO or CFO, in order to steal sensitive information from a company, as those that hold higher positions within the company typically have complete access to sensitive data. In many whaling phishing attacks, the attacker's goal is to manipulate the victim into authorizing high-value wire transfers to the attacker."

Guys, this paragraph is for you. It's not unusual I get unsolicited invites from LinkedIn. They include bearded guys whose name I cannot pronounce, I click Ignore. Nice looking gentlemen who are headhunters, maybe I accept or ignore. Various ladies who are headhunters, again I may accept or ignore. PhD or students of various types, I may accept if they have an interesting profile, otherwise I ignore. But I have never been invited by a babe-level (non-headhunter) who wanted to strike a conversation which is non-work / non-professional related - until now.....

Initial invitation -

So this under 30s, corporate entreprenuer and executive professional who appears to be running a company, decide to invite me in LinkedIn. Let's call her LX from here. To be specific her LinkedIn profile photo is not babe-level, but instead very professional and very expensive looking high class lady. So the invitation is unusual in the sense of it being rare (I don't get invitations like this) but not enough to be suspicious initially - maybe her work or project made her see something in my professional background that may be interesting - after all this is what LinkedIn is about, thank you. On a personal level, she is also the same ethnic background as myself, so in this case, that increased my interest a little.

Interaction -

The following is an account of the interaction and so far the interaction is still on going and there is no conclusion yet.

- After connection at LinkedIn, we started with well wishes and small conversations. Nothing unusual, but I'm quite excited to have this interaction.

- Not long after, LX admits she does not use LinkedIn much, and asks if I use WhatsApp or WeChat. Immediately I too wanted to move off from LinkedIn and continue our conversation privately in a non-professional platform for chats.

- On the Chat platform, the conversation continued. The conversations was very pleasant and non-committal. We started to talk about what each other is doing. From my personal view, I enjoyed this very much because it was refreshing to have a new friend who seemed to be very interested in my routine life. She was not nosy and not at all inquisitive of what I do. So no alarm bells there.

- I asked a few questions about her professional life, ie the business that she does. The questions were in the direction of trying to see if there is any synergies between my work and her work so there is more to talk about professionally, or help each other's business. Again this is quite standard in what LinkedIn is suppose to allow for.

- No business talk. However her response to work and business questions were polite and relevant, but usually ended quickly. For example, her company is multinational, and although they have offices in your country, she does not have direct dealings with your branch. This is quite plausible but adds or subtracts nothing in terms of evidence.

- How is your day? The conversation continues very politely and showing interest in daily life routine, such as how is your day, did you sleep well, have you eaten. These are all very nice and I'm very touched to have this level of interest from someone else.

- Niiice photos - Without making any requests, she voluntarily send me photos of herself doing sports (in tight sports gear, calm down you guys) and also showing her at dinner. The dinner picture of her is sensational - very photogenic. So of course I want to continue the interaction more.

- We talked about music, food, weekend activities. So very nice indeed. She does not seem to care about my family background, education background, social status. I have no pressure to try to impress her simply because she seems to have everything. Wow I really like to meet her. Even if for a purely platonic relationship (guys, please!), she is so refreshing to interact with.

- The summary of the interaction is so far we have both kept it very friendly and have not demanded anything from each other at all. Hence no pressure and no expectations. Other males in this position may have taken a different direction and I don't really know how she would respnd. In any case, at this point there is no cause for alarm based on the interaction in the chat room.

Let's now go to the other side of thought.....

Reality Check -

1. Who am I that such a perfect lady (looks, wealth, charm, humour) would pay attention to me? An old saying goes 'Look at your own cat-face (literal translation from another culture)', 'Look at your own mug-shot', 'Have you looked in the mirror lately'? This is one reality check that pulled me down to earth. Though not looking like Brad Pitt or George Clooney, etc, I do think I'm not bad looking at times. But with double chin, and an average look, really? would a pretty and wealthy and successful young lady choose me out of millions of nicer looking guys out there? (If you answer yes, you don't deserve sympathy if you are taken for a ride).

2. 'If it is too good to be true, then it is not true'.

Countless people with higher intelligence than myself have fallen victims to scams. I'm not qualified to give all the reasons why and how smart people get scammed, conned, tricked, but it happens all the time. To re-iterate many smart people fall for it. Simply put, when we see something is so good, and we really want it, then we will try to find all the reasons why this good thing can be true. It's not a matter of being optimistic that makes people vulnerable. Those who fall victim to scams, really do want the bait (money, pretty looking person, etc) - we all want something and sooner or later, there is scammer out there who would have the correct bait for us.

3. Use logic not our senses - A Beutifual Mind.

Men have often been accused of thinking, not with their brain, but with the organ below. If looking in the mirror does not bring a reality check (coz You're So Vain), then remember the movie A Beutiful Mind about the Noble Prize winning mathematician and schizophrenic John Nash. Spolier Alert: Since his university days, he was seeing an imaginary little child. Through his many years of struggle with schizophrenia including hospitalization and medication, he still believed the child was real because he saw with his own eyes, and hear with his own ears. This super briliant mathematician knew he had schizophrenia but cannot deny the existence of the little child. However, the Reality Check came one day, when he realised (using simple logic), that he knew this child (seeing and talking with her) for many decades of his life but she did not grow old. This is the reality check that even all his physical senses tell him it is real, simple logic about humans and ageing brought him out of his delusion and so he accepted the little girl cannot be real.

OK - let's put our suspiscious cap on for a moment. (Remember, nothing in the interaction so far seems like she wants anything or has anything to offer, except friendship. Neither of us have spoken anything other than what two very familiar friends would speak about.)

Profile:

- Profile photo included whole person, so her face is quite small in the picture.

- LinkedIn people also viewed other ladies with profiles which are very suggestive, yet with high corporate titles.

- She has a 500+ followers. Nothing wrong with that by itself.

- She has a very important, high position title, but somehow the wording is not quite right.

- Education and work experience profile is quite short. For a yound person, this is understandable. Two universities were listed. Three work experiences listed, the first is an internship. The third is the current very high and important sounding role.

None of these stand out too much by itself, but ordinarily I would not have accepted the Connect invitation with someone with a very brief education and work experience profile. So my confession is that I accepted because she was an interesting lady.

Suspicions - Putting on the tin-foil hat.

The conversations in the chat does not indicate she wanted anything from me, neither information nor resources. The LinkedIn profile described above is not unusual for each individual item, but collectively, they are starting to ring the alarm bells. From there, trying much harder to look through all the evidence, here is a list of suspicious items.

- In the interaction / chats, when I tried to talk about her business to stimulate her interest or passion in her work or business, her answers very soon changed the topic. It was not avoiding the question, but the answers were very plausible, but like 'now let's talk about something more interesting in your personal life'

- She does not ask me about my work, except simply 'what I do at work'. There is no attempt to extract any kind of work related information at all. In fact this almost lack of interest about my professional experience, considering we met at LinkedIn is a bit unsual I thought.

- She has so far send two photos. The photo in a sporting activity shows her in a tight exercise suit - revealing a nice body (sorry, I have say it as it attracted my attention). The one at dinner was very proper looking, showing such a cute and sweet face. But comparing these two photos with her LinkedIn profile photo and the chat app profile photo, I cannot say for sure that it is or it is not the same person. Each photo was taken either at a different angle, with different hair style and different pose, basically enough differences that it could still be the same person.

- Photos - another thing about the photos is that they are not selfies. So she always has someone with her, taking these nice photos of her, whether in an action during sports or at dinner for one, yet looking nice and framed properly in the photos. Who took these photos? Was she with someone? If there is someone, even a friend, why would she be chatting with me half way around the world instead of giving more attention to that person who is with her?

- Looking more closely at the education level in combination with the work experience. She attended two universities consecutively from 2011-2017. A brief internship was done. Then it appears her first job after the internship is CEO of a company (4 years ago until now) and and second job at the executive level from (3 years ago until now). So this is what I meant by a seemingly successful or wealthy young lady. Can this be true? Yes since her country is a place where rule-of-law is not always true, and important people (e.g. her father) has significant advantages. Or it could be a not-very-good fake profile.

- Looking at her LinkedIn connections, it is almost all males out of the first 8 pages with only one female who is another high-powered successful lady. All the males are CXO, C-level executives, directors, Heads of xyz, business leaders etc. Not even head-hunters has such high powered connections. Could all these male high-flying individuals be potential victims?

Why me? What for?

Although some alarm bells may start to tingle, most likely we may not know the reason until it is too late. Here are just a few very general reasons and there could be more.

https://www.smh.com.au/lifestyle/life-and-relationships/don-t-know-why-i-sent-more-sally-lost-her-entire-savings-to-a-love-scam-20200909-p55ttb.html

1. The article above is about old-fashioned scamminng involving romantic love, but the technology could be modern, like chat or video conferencing. The scammers are patient and build trust and love on the victims, then the objective of the scam is old-fashioned money.

2. For more modern whaling, the objective would be to target high level corporate leaders, or someone influential enough in an organisation, such as an IT Administrator. Then if the scammer can infect the devices of the victim, potentially everyone else in the victim's computer network (ie the office) could be vulnerable.

3. Social engineering - this may combined the old-fashioned charm and get-to-know-the-person-trick, then with the similar objective as whaling, by having the goal of being able to access information or computer systems of more high value targets in the organisation of the victim.

I don't think I can fall in the romantic scam trick, but that is in fact what I could fall for. I don't have a high title in my company nor important role, but that does not mean I cannot be used to get to another person through me. Just because I don't know why, does not make me any less valuable to a scammer.

4. Here is another potential reason (I won't comment further)

https://www.asianage.com/world/americas/310818/china-using-fake-linkedin-accounts-to-recruit-americans-us-top-spy-catcher.html

Checks

The suspicions above may or may not reflect the truth - and I still cannot be sure at this point.

However, a few things can be checked.

- Contact University? Alumni Lookup service?

- Check with a few others she has been in contact with.

- Check by calling the work company, maybe not directly, but approach with tact.

- Image check in the internet.

- Common scammer fake profiles search

Update:

I just verified using reverse image search (https://tineye.com/search/), that the chat app profile photo is taken from a young lady at a tourist website. The website has a lot of photos of the same lady and they are clearly recognizable as the same person. However, LX's various photo seem difficult to identify as the same person.

Offline Browser, Proxy Server, Cache for viewing web pages without the Internet

2020-08-23T08:41:00.002-07:00

The following is a work in progress to find a way to view web pages without the internet.

How to Enable Offline Browsing in Chrome - an experimental feature within Chrome and like browsers.

https://www.hongkiat.com/blog/windows-offline-browsers/ - a good list of offline browsers

https://proxy-offline-browser.com/professional/Installation.html - MM3 Web Assistant. This functions as a proxy and automatically saves the webpages that have been visited. However the free version does not handle HTTPS. The benefit is that users do not need to specify which sites to save specifically.

HTTrack Website Copier - seems to be the best so far. Will test soon.

WebCopy - similar to HTTrack but not JavaScript....

Wiki for Offline browsing

Download the linux version: http://xowa.org/home/wiki/Help/Download_XOWA.html
On Linux, open a terminal and run sh /home/Your_Name/xowa/xowa_linux.sh
Note that the shell script is a wrapper for java -Xmx256m -jar /home/Your_Name/xowa/xowa_linux.jar
Path of jar file /home/Your_Name/xowa/xowa_linux.jar

Or when doing this from within docker

# on host of containers

docker run -it ....alpine

# inside the container

apk add wget

wget https://github.com/gnosygnu/xowa/releases/download/v4.6.5.1911/xowa_app_linux_64_v4.6.5.1911.zip

apk update

apk get openjdk11

Notes Video Editing

2020-08-21T15:59:00.009-07:00

https://au.oberlo.com/blog/best-free-video-editing-software

I'll add comments to help narrow down even further for myself basically - but others may find it helpful too.

Blender - originally for 3D animation. I've also heard about its not-so-easy to learn aspect, though it has lots of features. But I won't be trying this.

Lightworks - the Free version has a limit of 720p. I've used another converter to convert to 1280x720 and compare with the original and very common 1920x1080 size. The 720 one is noticeably fuzzier. So I won't be testing this further.

Shortcut -

While the cut function seems OK, the Export is difficult to configure. Pressing the Export button does nothing. In one case when it did export, the file is more than twice the original.

OpenShot

not really that straight-forward to use without using any help
Export to a lot of formats, but for some reason, the output is 10 times larger than the original. Why it doesn't use the exact compression level of the input?

Avidemux

BEST so far
Small footprint, about 80MB fully installed (according to the installation dialog)
Best Feature - COPY - this option in the video encoder format allows it to use exactly the same video format as the input. So if there are no edits being made, the new output is exactly the same size. This is very useful in comparison with other software above which, in most cases, result in an output which is larger than the input video file.

Kapwing Online Editor

limited to 7 minutes clip for free version

Tensorflow Deployment Requirements for Machine Learning / Neural Networks

2020-07-26T06:49:00.005-07:00

This blog will be continuously updated.

Obviously from the title, out of the many Machine Learning (ML) framework, this post is about the Tensorflow (https://www.tensorflow.org/) framework as oppose to other ML frameworks. As a quick reference, the other ML frameworks are:

Caffe2 - https://caffe2.ai/

PyTorch - https://pytorch.org/

PyTorch vs TensorFlow — spotting the difference

https://towardsdatascience.com/pytorch-vs-tensorflow-spotting-the-difference-25c75777377b

TensorFlow vs Caffe - https://www.educba.com/tensorflow-vs-caffe/

Keypoints from this link is that Tensorflow is for the server whereas Caffe is for production edge deployment. Both support parallel computing but in a different way. Caffe needs to be installed by compiling from source, but Tensorflow is easier to deploy.

The following has simple instructions on how the setup the Tensorflow environment.

https://towardsdatascience.com/setup-an-environment-for-machine-learning-and-deep-learning-with-anaconda-in-windows-5d7134a3db10

https://towardsdatascience.com/installing-tensorflow-with-cuda-cudnn-and-gpu-support-on-windows-10-60693e46e781

The articles in the link above are helpful in determining which software versions will work with other software versions. Please note that the latest software version may not be compatible with other software it needs to work with.

Software Requirements:

Python

CUDA toolkit

cuDNN

Tensorflow

Keras - Python Deep Learning API which works on top of Tensorflow

Hardware Requirements:

GPU is optional. However, when GPU is preferred, and specifically CUDA is preferred, then the GPU will be from NVIDIA.

In terms of laptops, there are broad classes of laptops referred to as Workstations and other are Gaming laptops. Workstations are generally more expensive. In a particular search, a Workstation laptop with Quadro T2000 GPU is clearly more expensive than a Gaming laptop with RTX 2060 GPU card. Yet benchmarks show that the RTX2060 performs much better than the Quadro T2000.

https://browser.geekbench.com/cuda-benchmarks

Unboxing - AIMOS HDMI KVM 2-port Switch

2020-06-22T06:52:00.002-07:00

Below are some images of the manual

Chinese

Add caption

The package comes with two identical cables.

On one end of the cable is the normal USB connector which should be plug on your computers

On the other end of the cable is a connection that looks like a printer cable - this should of into the KVM.

There are 3 male-to-male HDMI cables that need to be purchased separately.

Cable 1 connect HDMI port on KVM to HDMI port on computer 1

Cable 2 connect HDMI port on KVM to HDMI port on computer 2

Cable 3 connect HDMI port on KVM (labelled 'output') to HDMI port on Monitor.

Once all cables are plugged in, the system is ready to be used.

Notes q

2020-04-28T14:08:00.003-07:00

You Tube - Introduction to KDB+ and q
An Overview of the q language

You Tube - Introduction to KDB+ and q
========================================
Tutorial: https://www.youtube.com/watch?v=8eoysfqO3UY&list=PLypX5sYuDqvrwBD2EMWadIMiTqJZmVsqm
The following is a transcribe of the details in the above introduction course. It is meant as rough notes to capture the syntax and used as a reference, and may not give good worded descriptions.

#lesson 1
NO: control flow, loop, if-else, threads, shared globals, objects, inheritance
interpretive language, dynamically type, vector programming, functional programming, list, dictionaries, tables (1st class items, based on list, dicts)

#lesson 2
function has TYPE
42 -> 64 bit
42i -> 32 bit
4%2 -> % is division
2f -> float

#lesson 3
1 2 3+10 20 30 -> vecotr operation, results is 11 22 33, spaces are used to separate list items
count 1.0 2.0 3.0 -> 3 is the result
1+10 20 30 -> 11 21 31 scalar(atom) + vector
# All operations have precedence, operations done right to left
2*3+4 -> (3+4) =7 then *2 =14
til 100 -> generates 01 2 ... up to 100 numbers
count til 100 -> 100
101+2*til 1000 -> generate (0 .. 999), then x 2, then add 100 to every item. Result: 101 103 105 ....

#lesson 4
0b -> false
1b -> true
101b -> list of booleans true, false, true, NOT separated by space, and NOT a bitmask representation
42=6*7 -> 1b (true)
1 2 3=10 2 30 -> 010b vector results of false, true, false
2018.01.01 -> actually count of days since millenium (yyyy.mm.dd)
2000.01.01=0 -> 1b True
1999.12.31=-1 -> 1b True
2000.02.01-2000.01.01 -> 31i (31 days, in INTEGER 'i') date arithmetic
2000.01.01+til 31 -> make 31 integers then add to 1st Jan 2000 -> gives the dates of that month. List-Date arithmetic
2000.01m -> month
2000.01m=0 -> 1b Comparing the 1st month since millennium
2000.02m=1 -> 1b Comparing the 2nd month since millennium
2000.01.01=2000.01m Comparing 1st day ever, to 1st month ever, q assumes the month is 1st day of month when comparing to date, hence true.

#lesson 5 - Casting
`long$1.0 -> cast to long
`float$1 -> cast to float
`boolean$1 -> cast to boolean
`date$31 -> cast to date format, ie 31 days since millennium is 2000.02.01
2000.01m+til 12 -> list of 12 months 2000.01 2000.02 2000.03 ...
15+2000.01m+til 3 -> 2001.04 2001.05 2001.06m 1st 3 months, after 15 months from the millenium

# lesson 6 - Operations on List
Declarative programming - what we want in q. Other languages are imperative, ie write loops to tell how to compute.
0 +/ 10 20 30 40 50 Initialise to zero then add the items on the list. The +/ symbol called 'over' in q, 'fold' in functional language.
(+/) 10 20 30 40 50 Same as above - add across a list. Does not need to be initialised.
'/' The slash is ALSO behaving like an iterator
sum 10 20 30 40 50 -> same as above
(*/) 1+til 5 Does Factorial(5)
4|5 -> 5 returns larger number
10&2 -> 2 returns smaller number
0b|1b -> 1b Larger operator for Boolean is equivalent to 'OR' operator
0b&1b -> 0b Smaller operator for Boolean is equivalent to 'AND' operator
(|/) 10 30 20 -> 30
max 10 30 20 -> 30
(&/) 10 30 20 -> 10
min 10 30 20 -> 10
(+\) 10 20 30 40 50 -> 10 30 60 100 150. Backslash means create a CUMULATIVE / RUNNING list. also called 'sums'
(&\) 40 20 30 10 50 -> 40 20 20 10 10. Running minimum. Also called 'mins'. Similarly with 'maxs'

# Lesson 7 - Functions
{[x]x*x} -> [x] is the parameter
{[x]x*x}5 -> substitutes 5 into x. Result is 5*5. Can also use {[x]x*x}[5]
{x*x}5 -> implicit parameter, don't need to declare.

# Lesson 8 - Newton Raphson and Fibonacci Sequence
Say Function is f(x) 2-x^2. So f'(x) = -2x. NewtRaph algo is xn = xn - f(x)/f'(x)
{[xn]xn+(2-xn*xn)%2*xn}/[1.0] -> 1.414214 .... result from Newton Raphson using 1.0 as initial point, being put into the function on the left iteratively.
{[xn]xn+(2-xn*xn)%2*xn}\[1.0] -> 1 1.5 1.4..... shows the intermediate results from Newton Raphson
\P 16 -> shows 16 decimals. iteration stops until diff is 1e-14
2#10 20 30 40 50 -> 10 20 '#' retrieves the integers from the left of list
-2#10 20 30 40 50 -> 40 50 '#' retrieves the integers from the right of list
10 20, 100 200 300 -> 10 20 100 200 300 joins lists
{x, sum -2#x}/[10;1 1] -> returns the Fibonacci Sequence. Iterate 10 times, starting with [1 1]

# Lesson 9 - Function, Variables
deltas 110 120 130 -> 110 10 10 takes differences between two numbers. The first result assumes difference with zero.
deltas sums 110 120 130 -> is the same as sums deltas 110 120 130 -> result is 110 120 130. Invariance in q.
a:42 -> assign value of 42 to variable a.
buys:2 1 4 3 5 4 ->
sell:12 -> want to sell 12 units from the various buys
sums buys -> 2 3 7 10 15 19
sell&sums buys -> 2 3 7 10 12 12 - creates a list of minimum between two lists.
deltas sell&sums buys -> 1 2 4 3 2 0 - list of what how should buy

# Lesson 10 - Tables
Table = Collection of columns in q. Operations are column based, hence vector operations.
dates:2018.01.01+10000000?31 -> list of 10 million numbers between 0(including BUT not stated) and 31(stated, but EXCLUSIVE)
times:10000000?24:00:00.0000 -> 10 million random nums, between 0 (including, BUT not stated) and midnight (EXCLUSIVE)
qtys:100*1+10000000?100 -> 10 mil random numbes from 0 to 100, then +1, then * 100
ixs:10000000?3 -> 10 mil rand num, from 0 1 2. store random numbers in ixs
10 20 30 ixs -> 10 10 30 20 30 20 ...... Since ixs has 3 unique values, so the 10 20 30 will apply to 10 20 30, MAPPED into the 10 million entries of ixs.
syms:`appl`amzn`googl ixs -> `googl`aapl`amzn`googl`googl .... applies symbols to list, store in syms. The 3 stock quotes is MAPPED to the 3 unique values of ixs for all 10 million values of ixs
172.0 1189.0 1073.0 ixs -> maps the 3 unique values into the 10million numbers of ixs
pxs:(1+10000000?.03) 172.0 1189.0 1073.0 ixs -> adds some random noise to the 10 million stock prices.
t:([] date:dates;time:times;sym:syms;qty:qtys;px:pxs) -> creates a table, with specified column names, and columns of data
t:`date`time xasc t -> sort ascending time, then date
5#t -> returns top(head) 5 rows

# Lesson 11 - qSQL
select date,time,qty,px from t where sym=`aapl
\t select date,time,qty,px from t where sym=`aapl -> returns time in milliseconds
first 10 20 30 40 50 -> first item on list
last 10 20 30 40 50 -> last item on list
select open:first px,close:last px by date,time from t where sym=`aapl

#Lesson 12 - Complex Queries(*)
4 3 2 1 wavg 10 20 30 40 -> 20f calculate weighted average
5 xbar 0 1 2 3 4 5 10 11 21 -> 0 0 0 0 0 5 10 10 20 returns bucketed result. Useful for time domain values that needs bucketing
select max px - mins px from t where sym=`appl -> is the Max idealised profit (ie buy at the lowest price of the day and sell at the highest price of the day. The function is the same as select (max (px - (mins px from t where sym=`appl) )). The mins is a running cumulative vector of the minimum, while the max just returns the single value.

#Lesson 13 - Interprocess Communication(*)
Server and Client - ie running two different q.
On Server
\p 4242 Starts the server on port 4242
On Client
h:hopen`::4242 Where machine name is omitted between two colons, since it is on the same machine. h is the handler
h "6*7" Do compute on remote server
sq:{x*x} Send function to remote server
h (sq; 5) Execute on remote server
DON'T DO ABOVE since open ports are dangerous
On Server
cub3:{0N!x*x*x} 0N! displays computation on local server first, before shifting to client
On Client
h (`cub3; 5) Safer this way, CALL the name of the function. First Argument is function name, the rest are arguments

#Lesson 14 - Callbacks(*)
Previously the client server were synchronous, meaning the parties wait for each other after sending a message.
For Asynchronous, when message is sent, the sender does not need to wait.
The handler h is an 'integers'.
On Client
h -> 3i is the integer 3. this is a function handler
(neg h) (`cub3;5) -> h is positive, neg h is negative. So "(neg h) (`cub3; 5)" is an ASYNCHRONOUS call.
Callback: Without callback, an asynchronous function would send message to server, then receives no response. With callback provided on the server, the server will send the result back whenever it is ready.
Client uses 'h' as its handler to call the server
Server uses '.z.w' as its handler of the function send from the client. .z.w returns 6i

On Client (FINAL)
continue:{0N!x} -> displays x over here
(neg h) (`worker; 5; `continue) -> (neg h) for asynchronous, call process 'worker' on server, with argument '5', use the callback label 'continue'. First Argument `worker is function name, the rest are arguments [5; `continue]

On Server (FINAL)
cub3:{0N!.z.w; x*x*x}
worker:{[arg; callback] r:cub3 arg; (neg .z.w) (callback; r) -> 'worker' is process called by client, defined here on server. [arg; callback] are the parameters passed from client. 'callback' is the dummy name corresponding to 'continue'. Runs cub3 on arg, store result in r. Then (neg .z.w) triggers the callback to client asynchronously. Thirdly execute the 'callback' (which is 'continue') with result r.

# Lesson 15 - I/O
Strings - abit different than other languages. Strings are a list of characters, not a primitive type.
"jab" is a list
`jab is a variable name
Binary files - operations have 1 in their names
Text files - operations have 0 in their names
File records are list of strings to q. Which means they are a list of list of characters to q.

("So long"; "and thanks"; "for all the dish") - a list of list of chars
count ("So long"; "and thanks"; "for all the dish") -> three list items
`:/data/solong.txt 0: ("So long"; "and thanks"; "for all the dish") -> `:/data/solong.txt returns this file handler as acknowledgment
' error messages are 'Straight ticks'
` File handlers are 'back ticks'
`: is the file handler or names a file.
/data/solong.txt is the local path
0: is the name of the WRITE to text file function
read0 is the name of the READ from text file operation
read0 `:/data/solong.txt -> prints out the lines of the file
`:/data/answer.txt 0: txt,txt:read0 `:/data/solong.txt -> `:/data/answer.txt returns this file handler as acknowledgment

Date - starts from the millennum
Vector Column operations - not Rows
select from 10million rows in 150ms
Single line of code for even for non-trivial functions

select max px - mins px from t where sym=`appl Algorithm for Idealised Profit in Trading (sym is symbol column, px is price column of table t )
{[xn]xn+(2-xn*xn)%2*xn}\[1.0] Algorithm for Newton Raphson with initial point as 1.0
{x, sum -2#x}/[10;1 1] Algorithm for Fibonacci Sequence, initial points 1 1 , for 10 iterations

An Overview of the q language
================================

'q' is a proprietary language build on top of an existing 'k' language (developed by ex-Morgan Stanley computer scientist Arthur Whitney) and the kdb+ datatbase (The 'q' language / kdb+ is free for non-commercial use). They are all proprietary products of Kx Systems and it is perhaps more widely known (if not the de facto) in the finance and investment banking industry more than any other industries. As such, it is aimed at time-series based data, large volumes and high transfer rates. Very complex applications can be written in the 'q' language with an extremely small footprint. A large number of Altair's real time visualisation software, Panopticon, connect to kdb+ databases and utilises q.

A recent exploration into the depths of the q language reveals a very sophisticated and expressive computational programming language. It is both like and unlike various programming languages. Perhaps the first point is the vector programming underlying its core, yet this language may not be known widely in the HPC community (or perhaps I have not looked wide enough while I was in HPC, it happens). Vector supercomputers once ruled the HPC world, but when they approached extinction, the vector processing capability were re-incarnated into commodity CPUs and is now powering our PCs (since the days of Intel MMX, SSE, etc...). And it appears that around that similar time shortly after the Millennium, 'q' was born independently of Vector Supercomputers or vectorised CPU instructions, but rather tracing its origin back to the 60s from APL (A Programming Language), thus having both vector and functional programming influence.

For reference, a free book is available at: https://code.kx.com/q4m3/0_Overview/
And a Tutorial series is at: https://www.youtube.com/playlist?list=PLypX5sYuDqvrwBD2EMWadIMiTqJZmVsqm

For those coming from scientific, computational, HPC background, thinking in terms of vectors will ease our understanding to 'q'. For the general programmers who are familiar with C, Java, Python, and the rest, the good advice from the YouTube link would be to throw away your understanding of control flow, loop, if-else, threads, shared globals, objects, inheritance. The syntax itself is short, succinct and raw, yet expresses beautifully the operations it performs. The following will describe some of the noteworthy things about 'q' which are different than the current popular programming languages.

'q' is similar to many scripting language, ie interpretative (no compilation), dynamically type (no pre-declaration of data type). The two fundamental data structures are lists and dictionary, again no surprises here. However it is the vector operations that are perhaps new to most modern day programmers. For example a vector 1 2 3 can be added directly to another vector 10 20 30. Yet these vector expressions should be reminiscent of those in Matlab and Fortran, but the similarities don't extend much further. The syntax is perhaps quite different (though perhaps not too dissimilar to other functional programming languages). The vector (list) items are delimited by spaces (not commas). The mathematical operators has equal precedence (no BODMAS rule) and the order is designed so that the operations are performed in the right-to-left order. For example: 2*3+4 is actually 2*7, which is 14. This right-to-left and single line way of writing code is perhaps the biggest change a programmer of other languages need to overcome.

Control flow and loops goes out the window because an operation acts on all the items in the vector. There is no point in having an explicit index to loop over. As such, an operation over 10 or 10 million items can be written in one line. In fact, entire functions or methods are written in one line, as shown in examples later. In terms of data types, there are the familiar char, boolean, integer, float and so on. Strings are like in Fortran or old C, a string in q is actually a character of arrays. The really most interesting data type I found is the Date representation. Instead of some arbitrary representation having an initial value at 1970 or 1900; q's date are actually integers starting from 1 Jan 2000. This means date computations benefit from the speed of raw integer operations, as well as being able to perform fancy date arithmetic.

List operations are powerful, since this is one of the core data structures of q. List, or vectors can be operated with another vector or scalar, not dissimilar at all to their mathematical counterparts. In addition to aggregate operations like 'max', 'min', 'sum', there are more interesting versions 'maxs', 'mins', 'sums' which actually returns a cumulative vector of the aggregation process. The highlight of the 'q' language of its expressiveness and power would be its function definitions. Instead of describing, ponder upon the following one-liner, and consider how such functions would need to be written in Python, Java, C, etc:
Algorithm for Newton Raphson with initial point as 1.0
{[xn]xn+(2-xn*xn)%2*xn}\[1.0]
Algorithm for Fibonacci Sequence, inital points 1 1 , for 10 iterations
{x, sum -2#x}[10;1 1]
Algorithm for Idealised Profit in Trading (sym is symbol column, px is price column of table t )
select max px - mins px from t where sym=`appl

As for Data Analytics and complex data processing, there are tables, qSQL and a few more useful functions. Tables are collection of columns, like Fortran/Matlab but opposite to C-based languages. Columns in tables generally mean they are of the same data type that means they are easily stored as vectors. For q, this means performing operations on large datasets are extremely fast. Combining the single line functional syntax with vector based operations, very complex yet efficient programs can be written in a terse manner. The qSQL syntax enables very SQL-like expressions to be written. This may be a comfort for SQL programmers, but it still pays to understand the underlying concepts of q, since there are fundamental differences that can lead to incorrect expectations. Native functions like 'xbar' that creates bucketing are extremely powerful when applied to time-series based analysis. In an example of 10million rows, a certain select operation took 150ms.

Most programming languages have the capability of File I/O. q also has File I/O for both text and binary files (again there is the similarity with Fortran's binary files capability, rather than the streams based files I/O of other languages). Not surprisingly by now, q's way or reading and writing files are one-liners. There is no need to open or close a file or the many other lines of instructions needed by other languages. Besides File I/O, q is also capable of Interprocess Communications and Asynchronous processes. Together, these capabilities enable q to write client-server applications without using any other external tools.

From this brief high level exploration, q seems to be an interesting, powerful and useful programmig language. It has the expressiveness of functional programming, the power of vector processing and the applicability to real high volume data computational needs. The fact that it is born within the Financial Trading sector by no means exclude it from being used in other industries. Whereever there is large numerical datasets that requires computation, q may be a good choice. These other industries that may benefit include: data science, scientific research, defence, telecommunications, etc. In terms of providing real-time visualisations of the large and fast datasets, Altair's Panopticon with kdb+/q would make a formidable combination.