jared/cc-os

Watch

Fork 0

S9: take the moment topic from the predictor's Toward line; leave out shown predictions without one #1299

New issue

Closed

opened 2026-10-23 22:23:45 +00:00 by jared · 2 comments

jared commented

2026-10-23 22:23:45 +00:00

Owner

Problem

OsMe::MomentTopic (plugins/os-me/lib/os_me/moment_topic.rb) gives each ruling moment the text that PatternClusterer embeds. It reads only the shown AI message: the Toward: value of a PREDICTION block in that text, else the first line that is not a heading or a stock opener, else the stored headline. When the main session rewrites a prediction as markdown before it shows it, the shown text has no Toward: line. The first plain line is then layout (**Predicted action:** ..., **The predicted reply:**), not the topic.

Measured live on 2026-10-23: 280 ruling memo moments in 133 transcripts; 63 transcripts contain a Toward: line anywhere. After #1289, #1293, and #1294, the live refresh gave 2 candidates, and both were layout clusters. The predictor Agent's own result in the same turn holds the Toward: line, but MomentTopic never reads tool results or task notifications.

Ruling (Jared, 2026-10-23, accepted prediction): option A, then B.

A: take the topic from the predictor Agent's own result in the same turn, before the shown text.
B: a ruling moment whose AI message is a shown prediction, and for which A finds no Toward, is left out of clustering (no embed, no cluster) until #1292 makes new predictions carry a toward field.

Definitions used below:

Turn of a moment: the transcript entries after the typed user message that opened the turn (or the file start) up to and including the moment's AI entry (ai_index). Entries after ai_index are not in the turn.
Agent result: the text of a main-thread tool_result block whose tool_use_id is the id of a main-thread tool_use block named Agent in the same turn, or the <result> text of a main-thread task notification in the same turn (a background predictor returns through a task notification). The tool_result content is a string or an array of {type: text} items joined with newlines.
Shown prediction: the AI text has a line that, after strip, matches /\A[*_]*\s*(?:The\s+)?Predict|\A[*_]*\s*This is a [*_]*prediction/i. A heading line (starts with #) never matches, so ## Prediction alone does not mark a shown prediction.

Topic order per moment:

The PredictionParser#toward value of the last Agent result in the turn that has one.
PredictionParser#toward of the AI text.
Shown prediction: no topic; the moment is left out.
The first line that is not a heading or a stock opener (Short answer, You are right).
The stored headline. A missing transcript also gives the stored headline.

Approach

Entry learns to read Agent calls and tool results; a new TurnResults collects the Agent results of one turn; ExchangeFinder#pairs gives each Pair its turn's Agent results, so MomentTopic still reads each transcript once and adds no transcript parser. MomentTopic calls PredictionParser#toward on each Agent result text, so the YAML path that #1292 adds to toward works with no change here. prediction_parser.rb is not edited. MomentTopic#texts returns nil for a left-out moment, and PatternClusterer drops those moments before it embeds. The This is a prediction stock opener is removed because the shown-prediction rule now covers it; the two #1293 disclaimer tests change to expect no embed.

Required work:

Entry gets AGENT_TOOL = 'Agent', agent_call_ids (ids of main-thread assistant tool_use blocks named Agent), and tool_results (hash of tool_use_id to result text for main-thread user tool_result blocks, string or text-item array content). check: present def agent_call_ids in plugins/os-me/lib/os_me/entry.rb
Entry#tool_results returns the joined result text per tool_use_id. check: present def tool_results in plugins/os-me/lib/os_me/entry.rb
New OsMe::TurnResults collects, for one turn, the Agent call ids it has seen, the tool_results texts for those ids, and each notification_text, in transcript order. check: present class TurnResults in plugins/os-me/lib/os_me/turn_results.rb
Pair gets the member agent_results, default [], so existing Pair.new callers stay valid. check: present :agent_results in plugins/os-me/lib/os_me/pair.rb
ExchangeFinder#pairs starts a new TurnResults at each typed reply, snapshots its texts when it records the last AI entry, and builds each Pair with keyword arguments that include agent_results:. ExchangeFinder#find does not change. check: present TurnResults.new in plugins/os-me/lib/os_me/exchange_finder.rb
MomentTopic maps ai_index to the whole Pair, applies the topic order above, and returns nil for a shown prediction with no Toward. check: present SHOWN_PREDICTION in plugins/os-me/lib/os_me/moment_topic.rb
MomentTopic reads the Agent results through pair.agent_results and @parser.toward. check: present agent_results in plugins/os-me/lib/os_me/moment_topic.rb
Remove the This is a prediction entry from STOCK_OPENERS. check: absent This is a \**\s*prediction in plugins/os-me/lib/os_me/moment_topic.rb
PatternClusterer#cluster keeps only the rulings whose topic is not nil, returns [] when none are kept, and embeds only the kept topics. check: present kept in plugins/os-me/lib/os_me/pattern_clusterer.rb
Test fixtures get an Agent call (assistant tool_use named Agent with an id) and its result (user tool_result with that tool_use_id). check: present def agent_call in plugins/os-me/test/test_helper.rb
New test file for the acceptance criteria through CandidateRefresh#run. check: present class CandidateRefreshAgentTowardTest in plugins/os-me/test/candidate_refresh_agent_toward_test.rb
The two disclaimer tests in the stock-opener test file now expect no embed for a disclaimer with no Toward. check: absent clustering: Use option B for the cache. in plugins/os-me/test/candidate_refresh_stock_opener_test.rb

Acceptance criteria

All tests use fixture transcripts in a temp dir, a TranscriptCatalog over that dir, a moments log with ruling moments that carry transcript_path and ai_index, and a fake embedder that records its input. No model, no network. Each runs CandidateRefresh#run.

Given a turn of typed go, an assistant Agent call with id a1, a tool_result for a1 whose content is an array of text items holding PREDICTION and Toward: cache the index, then the AI text **Predicted action:** accept, then typed yes, when the refresh runs, then the embedder receives exactly ["clustering: cache the index"].
Given the same turn but the AI text also holds a PREDICTION block with Toward: other topic, and the tool_result content is a plain string, when the refresh runs, then the embedder receives ["clustering: cache the index"] (the Agent result wins).
Given a task notification whose <result> holds PREDICTION and Toward: drop the worker between the typed message and the AI text **The predicted reply:** yes, when the refresh runs, then the embedder receives ["clustering: drop the worker"].
Given an Agent result with a Toward line in the previous turn (before the typed message that opens the moment's turn), and a second moment whose AI text is the plain line Keep two workers., when the refresh runs, then the moment whose AI text is **The predicted reply:** yes is not embedded and the embedder receives only ["clustering: Keep two workers."].
Given a tool_result for a Read call (not an Agent call) whose text holds PREDICTION and Toward: template topic, and the AI text Drop the second worker., when the refresh runs, then the embedder receives ["clustering: Drop the second worker."].
Given only ruling moments whose AI texts are **Predicted action:** accept, **The predicted reply:** yes, *This is a prediction, not your ruling.*, and This is a **prediction, not a decision**., each with no Toward anywhere in its turn, when the refresh runs, then the embedder is never called and no candidate log file exists.
Given the AI text ## Prediction, **Short answer:** yes, Drop the second worker. and no Agent result, when the refresh runs, then the embedder receives ["clustering: Drop the second worker."].
Given three moments in three transcripts whose Agent results all hold Toward: cache the index and an embedder that maps that text to one vector, when the refresh runs, then the candidate log holds one open row with the three moment ids.

Owner sketch

module OsMe
  class Entry
    AGENT_TOOL = 'Agent'

    def agent_call_ids
      return [] unless main_thread? && @data['type'] == 'assistant'

      blocks.select { |block| block['type'] == 'tool_use' && block['name'] == AGENT_TOOL }.map { |block| block['id'] }
    end

    def tool_results
      return {} unless main_thread? && @data['type'] == 'user'

      blocks.select { |block| block['type'] == 'tool_result' }
            .to_h { |block| [block['tool_use_id'], result_text(block['content'])] }
    end

    private

    def result_text(content)
      content.is_a?(Array) ? content.map { |item| item['text'].to_s }.join("\n") : content.to_s
    end
  end

  class TurnResults
    attr_reader :texts

    def initialize
      @agent_ids = []
      @texts = []
    end

    def observe(entry)
      @agent_ids.concat(entry.agent_call_ids)
      @texts.concat(entry.tool_results.slice(*@agent_ids).values)
      notification = entry.notification_text
      @texts << notification if notification
    end
  end

  class Pair < Data.define(:session_id, :transcript_path, :ai_index, :reply_index, :ai_text, :reply_text, :ai_at,
                           :reply_at, :agent_results)
    def initialize(agent_results: [], **)
      super
    end
  end

  class ExchangeFinder
    def pairs(path)
      session_id = @catalog.session_id(path)
      last_ai = nil
      turn = TurnResults.new
      TranscriptReader.new(path).each_entry.filter_map do |index, entry|
        turn.observe(entry)
        last_ai = [index, entry, turn.texts.dup] if entry.assistant_text
        next unless entry.typed_reply

        turn = TurnResults.new
        next unless last_ai

        ai_index, ai, agent_results = last_ai
        last_ai = nil
        Pair.new(session_id: session_id, transcript_path: path, ai_index: ai_index, reply_index: index,
                 ai_text: ai.assistant_text, reply_text: entry.typed_reply, ai_at: ai.timestamp,
                 reply_at: entry.timestamp, agent_results: agent_results)
      end
    end
  end

  class MomentTopic
    STOCK_OPENERS = [/\A\**\s*Short answer/i, /\A\**\s*You are right/i].freeze
    SHOWN_PREDICTION = /\A[*_]*\s*(?:The\s+)?Predict|\A[*_]*\s*This is a [*_]*prediction/i

    def texts(moments)
      pairs = pairs_by_path(moments)
      moments.map do |moment|
        pair = pairs.fetch(moment['transcript_path'], {})[moment['ai_index']]
        pair ? topic_of(pair, moment['headline']) : moment['headline']
      end
    end

    private

    def topic_of(pair, headline)
      agent_toward(pair) || @parser.toward(pair.ai_text) || unshown_topic(pair.ai_text, headline)
    end

    def agent_toward(pair)
      pair.agent_results.reverse.lazy.filter_map { |text| @parser.toward(text) }.first
    end

    def unshown_topic(ai_text, headline)
      return if shown_prediction?(ai_text)

      plain_line(ai_text) || headline
    end

    def shown_prediction?(ai_text)
      ai_text.lines.any? { |line| line.strip.match?(SHOWN_PREDICTION) }
    end
  end

  class PatternClusterer
    def cluster(moments)
      rulings = moments.select { |moment| ruling?(moment) }
      kept = rulings.zip(@topics.texts(rulings)).select { |_moment, topic| topic }
      return [] if kept.empty?

      vectors = @embedder.embed(kept.map { |_moment, topic| "#{PREFIX}#{topic}" })
      group(kept, vectors).map { |_seed, members, topic| PatternCluster.new(members, topic: topic) }
    end
  end
end

Scope and blocking

Blocked by: none.

In scope: entry.rb, new turn_results.rb, pair.rb, exchange_finder.rb, moment_topic.rb, pattern_clusterer.rb, test/test_helper.rb, the new test file, and the two disclaimer tests in test/candidate_refresh_stock_opener_test.rb.

Out of scope: prediction_parser.rb (#1292 owns it and adds the YAML path to toward; this ticket only calls toward), the Store, the candidate file, the SessionStart hook, ExchangeFinder#find, and MomentExtractor.

Merge order: this ticket must merge after #1292 only if #1292 also edits one of the in-scope files above. When drafted, the #1292 worktree had not changed moment_topic.rb.

Origin

Trigger: Jared accepted the prediction for S9 option A then B on 2026-10-23 after three fixes left only layout clusters
Improvised this session: candidate file held out of the Store so the SessionStart hook asks nothing
Chain: layout clusters ← shown predictions rewritten in session markdown with no Toward line ← MomentTopic reads only the shown AI text. Stop at CODE (plugins/os-me/lib/os_me/moment_topic.rb).
Root candidate: none found
Where: plugins/os-me/lib/os_me/moment_topic.rb
Session: 4f3f95ea-3c6f-4d23-a0ea-e349d6ab02a5
Transcript: /home/jared/.claude/projects/-home-jared-dev-cc-os/4f3f95ea-3c6f-4d23-a0ea-e349d6ab02a5.jsonl

VERDICT: CREATE (user-approved; backlog search only)

## Problem `OsMe::MomentTopic` (`plugins/os-me/lib/os_me/moment_topic.rb`) gives each ruling moment the text that `PatternClusterer` embeds. It reads only the shown AI message: the `Toward:` value of a PREDICTION block in that text, else the first line that is not a heading or a stock opener, else the stored headline. When the main session rewrites a prediction as markdown before it shows it, the shown text has no `Toward:` line. The first plain line is then layout (`**Predicted action:** ...`, `**The predicted reply:**`), not the topic. Measured live on 2026-10-23: 280 ruling memo moments in 133 transcripts; 63 transcripts contain a `Toward:` line anywhere. After #1289, #1293, and #1294, the live refresh gave 2 candidates, and both were layout clusters. The predictor Agent's own result in the same turn holds the `Toward:` line, but `MomentTopic` never reads tool results or task notifications. Ruling (Jared, 2026-10-23, accepted prediction): option A, then B. - A: take the topic from the predictor Agent's own result in the same turn, before the shown text. - B: a ruling moment whose AI message is a shown prediction, and for which A finds no Toward, is left out of clustering (no embed, no cluster) until #1292 makes new predictions carry a `toward` field. Definitions used below: - Turn of a moment: the transcript entries after the typed user message that opened the turn (or the file start) up to and including the moment's AI entry (`ai_index`). Entries after `ai_index` are not in the turn. - Agent result: the text of a main-thread `tool_result` block whose `tool_use_id` is the `id` of a main-thread `tool_use` block named `Agent` in the same turn, or the `<result>` text of a main-thread task notification in the same turn (a background predictor returns through a task notification). The `tool_result` `content` is a string or an array of `{type: text}` items joined with newlines. - Shown prediction: the AI text has a line that, after `strip`, matches `/\A[*_]*\s*(?:The\s+)?Predict|\A[*_]*\s*This is a [*_]*prediction/i`. A heading line (starts with `#`) never matches, so `## Prediction` alone does not mark a shown prediction. Topic order per moment: 1. The `PredictionParser#toward` value of the last Agent result in the turn that has one. 2. `PredictionParser#toward` of the AI text. 3. Shown prediction: no topic; the moment is left out. 4. The first line that is not a heading or a stock opener (`Short answer`, `You are right`). 5. The stored headline. A missing transcript also gives the stored headline. ## Approach `Entry` learns to read Agent calls and tool results; a new `TurnResults` collects the Agent results of one turn; `ExchangeFinder#pairs` gives each `Pair` its turn's Agent results, so `MomentTopic` still reads each transcript once and adds no transcript parser. `MomentTopic` calls `PredictionParser#toward` on each Agent result text, so the YAML path that #1292 adds to `toward` works with no change here. `prediction_parser.rb` is not edited. `MomentTopic#texts` returns `nil` for a left-out moment, and `PatternClusterer` drops those moments before it embeds. The `This is a prediction` stock opener is removed because the shown-prediction rule now covers it; the two #1293 disclaimer tests change to expect no embed. Required work: 1. `Entry` gets `AGENT_TOOL = 'Agent'`, `agent_call_ids` (ids of main-thread assistant `tool_use` blocks named `Agent`), and `tool_results` (hash of `tool_use_id` to result text for main-thread user `tool_result` blocks, string or text-item array content). check: present `def agent_call_ids` in `plugins/os-me/lib/os_me/entry.rb` 2. `Entry#tool_results` returns the joined result text per `tool_use_id`. check: present `def tool_results` in `plugins/os-me/lib/os_me/entry.rb` 3. New `OsMe::TurnResults` collects, for one turn, the Agent call ids it has seen, the `tool_results` texts for those ids, and each `notification_text`, in transcript order. check: present `class TurnResults` in `plugins/os-me/lib/os_me/turn_results.rb` 4. `Pair` gets the member `agent_results`, default `[]`, so existing `Pair.new` callers stay valid. check: present `:agent_results` in `plugins/os-me/lib/os_me/pair.rb` 5. `ExchangeFinder#pairs` starts a new `TurnResults` at each typed reply, snapshots its texts when it records the last AI entry, and builds each `Pair` with keyword arguments that include `agent_results:`. `ExchangeFinder#find` does not change. check: present `TurnResults.new` in `plugins/os-me/lib/os_me/exchange_finder.rb` 6. `MomentTopic` maps `ai_index` to the whole `Pair`, applies the topic order above, and returns `nil` for a shown prediction with no Toward. check: present `SHOWN_PREDICTION` in `plugins/os-me/lib/os_me/moment_topic.rb` 7. `MomentTopic` reads the Agent results through `pair.agent_results` and `@parser.toward`. check: present `agent_results` in `plugins/os-me/lib/os_me/moment_topic.rb` 8. Remove the `This is a prediction` entry from `STOCK_OPENERS`. check: absent `This is a \**\s*prediction` in `plugins/os-me/lib/os_me/moment_topic.rb` 9. `PatternClusterer#cluster` keeps only the rulings whose topic is not `nil`, returns `[]` when none are kept, and embeds only the kept topics. check: present `kept` in `plugins/os-me/lib/os_me/pattern_clusterer.rb` 10. Test fixtures get an Agent call (assistant `tool_use` named `Agent` with an `id`) and its result (user `tool_result` with that `tool_use_id`). check: present `def agent_call` in `plugins/os-me/test/test_helper.rb` 11. New test file for the acceptance criteria through `CandidateRefresh#run`. check: present `class CandidateRefreshAgentTowardTest` in `plugins/os-me/test/candidate_refresh_agent_toward_test.rb` 12. The two disclaimer tests in the stock-opener test file now expect no embed for a disclaimer with no Toward. check: absent `clustering: Use option B for the cache.` in `plugins/os-me/test/candidate_refresh_stock_opener_test.rb` ## Acceptance criteria All tests use fixture transcripts in a temp dir, a `TranscriptCatalog` over that dir, a moments log with ruling moments that carry `transcript_path` and `ai_index`, and a fake embedder that records its input. No model, no network. Each runs `CandidateRefresh#run`. 1. Given a turn of typed `go`, an assistant `Agent` call with id `a1`, a `tool_result` for `a1` whose content is an array of text items holding `PREDICTION` and `Toward: cache the index`, then the AI text `**Predicted action:** accept`, then typed `yes`, when the refresh runs, then the embedder receives exactly `["clustering: cache the index"]`. 2. Given the same turn but the AI text also holds a PREDICTION block with `Toward: other topic`, and the `tool_result` content is a plain string, when the refresh runs, then the embedder receives `["clustering: cache the index"]` (the Agent result wins). 3. Given a task notification whose `<result>` holds `PREDICTION` and `Toward: drop the worker` between the typed message and the AI text `**The predicted reply:** yes`, when the refresh runs, then the embedder receives `["clustering: drop the worker"]`. 4. Given an Agent result with a Toward line in the previous turn (before the typed message that opens the moment's turn), and a second moment whose AI text is the plain line `Keep two workers.`, when the refresh runs, then the moment whose AI text is `**The predicted reply:** yes` is not embedded and the embedder receives only `["clustering: Keep two workers."]`. 5. Given a `tool_result` for a `Read` call (not an Agent call) whose text holds `PREDICTION` and `Toward: template topic`, and the AI text `Drop the second worker.`, when the refresh runs, then the embedder receives `["clustering: Drop the second worker."]`. 6. Given only ruling moments whose AI texts are `**Predicted action:** accept`, `**The predicted reply:** yes`, `*This is a prediction, not your ruling.*`, and `This is a **prediction, not a decision**.`, each with no Toward anywhere in its turn, when the refresh runs, then the embedder is never called and no candidate log file exists. 7. Given the AI text `## Prediction`, `**Short answer:** yes`, `Drop the second worker.` and no Agent result, when the refresh runs, then the embedder receives `["clustering: Drop the second worker."]`. 8. Given three moments in three transcripts whose Agent results all hold `Toward: cache the index` and an embedder that maps that text to one vector, when the refresh runs, then the candidate log holds one open row with the three moment ids. ## Owner sketch ```ruby module OsMe class Entry AGENT_TOOL = 'Agent' def agent_call_ids return [] unless main_thread? && @data['type'] == 'assistant' blocks.select { |block| block['type'] == 'tool_use' && block['name'] == AGENT_TOOL }.map { |block| block['id'] } end def tool_results return {} unless main_thread? && @data['type'] == 'user' blocks.select { |block| block['type'] == 'tool_result' } .to_h { |block| [block['tool_use_id'], result_text(block['content'])] } end private def result_text(content) content.is_a?(Array) ? content.map { |item| item['text'].to_s }.join("\n") : content.to_s end end class TurnResults attr_reader :texts def initialize @agent_ids = [] @texts = [] end def observe(entry) @agent_ids.concat(entry.agent_call_ids) @texts.concat(entry.tool_results.slice(*@agent_ids).values) notification = entry.notification_text @texts << notification if notification end end class Pair < Data.define(:session_id, :transcript_path, :ai_index, :reply_index, :ai_text, :reply_text, :ai_at, :reply_at, :agent_results) def initialize(agent_results: [], **) super end end class ExchangeFinder def pairs(path) session_id = @catalog.session_id(path) last_ai = nil turn = TurnResults.new TranscriptReader.new(path).each_entry.filter_map do |index, entry| turn.observe(entry) last_ai = [index, entry, turn.texts.dup] if entry.assistant_text next unless entry.typed_reply turn = TurnResults.new next unless last_ai ai_index, ai, agent_results = last_ai last_ai = nil Pair.new(session_id: session_id, transcript_path: path, ai_index: ai_index, reply_index: index, ai_text: ai.assistant_text, reply_text: entry.typed_reply, ai_at: ai.timestamp, reply_at: entry.timestamp, agent_results: agent_results) end end end class MomentTopic STOCK_OPENERS = [/\A\**\s*Short answer/i, /\A\**\s*You are right/i].freeze SHOWN_PREDICTION = /\A[*_]*\s*(?:The\s+)?Predict|\A[*_]*\s*This is a [*_]*prediction/i def texts(moments) pairs = pairs_by_path(moments) moments.map do |moment| pair = pairs.fetch(moment['transcript_path'], {})[moment['ai_index']] pair ? topic_of(pair, moment['headline']) : moment['headline'] end end private def topic_of(pair, headline) agent_toward(pair) || @parser.toward(pair.ai_text) || unshown_topic(pair.ai_text, headline) end def agent_toward(pair) pair.agent_results.reverse.lazy.filter_map { |text| @parser.toward(text) }.first end def unshown_topic(ai_text, headline) return if shown_prediction?(ai_text) plain_line(ai_text) || headline end def shown_prediction?(ai_text) ai_text.lines.any? { |line| line.strip.match?(SHOWN_PREDICTION) } end end class PatternClusterer def cluster(moments) rulings = moments.select { |moment| ruling?(moment) } kept = rulings.zip(@topics.texts(rulings)).select { |_moment, topic| topic } return [] if kept.empty? vectors = @embedder.embed(kept.map { |_moment, topic| "#{PREFIX}#{topic}" }) group(kept, vectors).map { |_seed, members, topic| PatternCluster.new(members, topic: topic) } end end end ``` ## Scope and blocking Blocked by: none. In scope: `entry.rb`, new `turn_results.rb`, `pair.rb`, `exchange_finder.rb`, `moment_topic.rb`, `pattern_clusterer.rb`, `test/test_helper.rb`, the new test file, and the two disclaimer tests in `test/candidate_refresh_stock_opener_test.rb`. Out of scope: `prediction_parser.rb` (#1292 owns it and adds the YAML path to `toward`; this ticket only calls `toward`), the Store, the candidate file, the SessionStart hook, `ExchangeFinder#find`, and `MomentExtractor`. Merge order: this ticket must merge after #1292 only if #1292 also edits one of the in-scope files above. When drafted, the #1292 worktree had not changed `moment_topic.rb`. ## Origin - Trigger: Jared accepted the prediction for S9 option A then B on 2026-10-23 after three fixes left only layout clusters - Improvised this session: candidate file held out of the Store so the SessionStart hook asks nothing - Chain: layout clusters ← shown predictions rewritten in session markdown with no Toward line ← MomentTopic reads only the shown AI text. Stop at CODE (`plugins/os-me/lib/os_me/moment_topic.rb`). - Root candidate: none found - Where: plugins/os-me/lib/os_me/moment_topic.rb - Session: 4f3f95ea-3c6f-4d23-a0ea-e349d6ab02a5 - Transcript: /home/jared/.claude/projects/-home-jared-dev-cc-os/4f3f95ea-3c6f-4d23-a0ea-e349d6ab02a5.jsonl VERDICT: CREATE (user-approved; backlog search only)

jared added the

project/cc-os

filed-by/user

category/code-change

labels

2026-10-23 22:23:45 +00:00

jared referenced this issue

2026-10-23 22:27:30 +00:00

os-me: the predictor returns YAML; PredictionParser reads YAML and the old line format #1292

jared commented

2026-10-23 22:28:43 +00:00

Author

Owner

Work started on branch ticket-1299 (os-sdlc implement). #1292 is merged.

jared commented

2026-10-23 22:36:44 +00:00

Author

Owner

Resolution

Done: MomentTopic takes the topic from the predictor agent's Toward line first, then the AI-text Toward line; a shown prediction with no Toward line is left out of clustering; Entry, TurnResults, Pair and ExchangeFinder carry the Agent result texts of each turn.

Evidence: Implementation 156 complete, all ten dispatches pass, 7 min 33 s; commits 669e1029 and da487003 on ticket-1299; suite gate green.

Follow-ups: none

## Resolution **Done:** MomentTopic takes the topic from the predictor agent's Toward line first, then the AI-text Toward line; a shown prediction with no Toward line is left out of clustering; Entry, TurnResults, Pair and ExchangeFinder carry the Agent result texts of each turn. **Evidence:** Implementation 156 complete, all ten dispatches pass, 7 min 33 s; commits 669e1029 and da487003 on ticket-1299; suite gate green. **Follow-ups:** none

jared closed this issue

2026-10-23 22:36:44 +00:00

jared referenced this issue from a commit

2026-10-23 22:37:48 +00:00

feat(os-me): Audited POODR boundaries for 1299: Entry reads Agent calls and tool results, TurnResults owns the Agent result texts and last AI entry of one turn, ExchangeFinder pairs builds keyword Pairs with agent_results, MomentTopic owns the topic order and the shown prediction rule, PatternClusterer drops nil topics before embed; contracts held; R1 to R12 present. (#1299)

jared referenced this issue from a commit

2026-10-23 22:37:48 +00:00

docs(os-me): Record #1299 topic from the predictor Toward line (#1299)